use strict;
use warnings;

use HTTP::Tiny;
use JSON;
use Data::Dumper;

# Initialize HTTP client
my $http = HTTP::Tiny->new();

# Define the server and endpoint
my $server = 'https://remap-rest.univ-amu.fr';
my $ext = '/api/V1/get_peaks/2022/hg38/all/chr5:100000-150000/target/CTCF;FOXA1';

# Perform the GET request
my $response = $http->get($server.$ext, {
  headers => { 'Content-Type' => 'application/json' }
});

# Check if the request was successful
if (!$response->{success}) {
  die "Failed to retrieve data: $response->{status} $response->{reason}\n";
}

# Decode the JSON response
my $content = $response->{content};
my $data = decode_json($content);

# Print the results
print Dumper($data);

Explanation:

• HTTP::Tiny: This example uses the HTTP::Tiny module to make an HTTP GET request to the API.
• Response Handling: The response is checked for success, and the content is decoded from JSON format.
• Error Handling: If the request fails, an error message is printed with details on the failure.

Ensure that you have the necessary Perl modules installed via CPAN to run this script successfully.

import requests

# Define the server and endpoint
server = "https://remap-rest.univ-amu.fr"
ext = "/api/V1/get_peaks/2022/hg38/all/chr5:100000-150000/target/CTCF;FOXA1"

# Perform the GET request
response = requests.get(server + ext, headers={"Content-Type": "application/json"})

# Check if the request was successful
if not response.ok:
    print(f"Failed to retrieve data: {response.status_code} {response.reason}")
    response.raise_for_status()

# Decode the JSON response
data = response.json()

# Print the results
import json
print(json.dumps(data, indent=2))

This script uses the requests library to make the GET request and the json library to print the formatted response. Make sure you have the requests library installed:

pip install requests

 
import java.net.URL;
import java.net.URLConnection;
import java.net.HttpURLConnection;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.Reader;
import com.google.gson.*;

public class ReMapApiClient {
    public static void main(String[] args) throws Exception {
        String server = "http://localhost:8000/";
        String ext = "api/V1/get_peaks/2022/hg38/all/chr5:100000-150000/target/CTCF;FOXA1?format=json";
        URL url = new URL(server + ext);

        URLConnection connection = url.openConnection();
        HttpURLConnection httpConnection = (HttpURLConnection)connection;

        httpConnection.setRequestProperty("Content-Type", "application/json");

        InputStream response = connection.getInputStream();
        int responseCode = httpConnection.getResponseCode();

        if(responseCode != 200) {
            throw new RuntimeException("Response code was not 200. Detected response was "+responseCode);
        }

        String output;
        Reader reader = null;
        try {
            reader = new BufferedReader(new InputStreamReader(response, "UTF-8"));
            StringBuilder builder = new StringBuilder();
            char[] buffer = new char[8192];
            int read;
            while ((read = reader.read(buffer, 0, buffer.length)) > 0) {
                builder.append(buffer, 0, read);
            }
            output = builder.toString();
        }
        finally {
            if (reader != null) try {
                reader.close();
            }
            catch (IOException logOrIgnore) {
                logOrIgnore.printStackTrace();
            }
        }
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        JsonElement je = JsonParser.parseString(output);
        String prettyJsonString = gson.toJson(je);
        System.out.println(prettyJsonString);
    }
}

Explanation

• URL Setup: The URL object is created with the base server URL and the specific API endpoint for fetching peak data.
• Connection: An HttpURLConnection object is used to open a connection to the API endpoint and set the request property to application/json to specify the data format.
• Response Handling: The response is read from the input stream. A BufferedReader is used to efficiently read the response data into a StringBuilder.
• Response Code Check: The response code is checked to ensure it is 200 (HTTP OK). If not, an exception is thrown.
• JSON Formatting: The response is parsed into a JSON object using Gson, and formatted into a pretty-printed JSON string for easier readability.
• Error Handling: Includes handling for potential IOExceptions during reading and closing of the reader.

Ensure that you have the Gson library included in your project to use Gson for JSON parsing and pretty-printing.

# Load necessary libraries
library(httr)
library(jsonlite)

# Define the server and endpoint
server <- "http://localhost:8000"
endpoint <- "/api/V1/get_peaks/2022/hg38/all/chr5:100000-150000/target/CTCF;FOXA1"
url <- paste0(server, endpoint)

# Perform the GET request
response <- GET(url, add_headers(`Content-Type` = "application/json"))

# Check if the request was successful
if (status_code(response) != 200) {
  stop("Failed to retrieve data: HTTP error code ", status_code(response))
}

# Decode the JSON response
data <- fromJSON(content(response, "text"))

# Print the results
print(data)

Explanation:

• httr and jsonlite: This example uses the httr package to make the HTTP GET request and the jsonlite package to handle JSON data.
• Response Handling: The response is checked for a successful status code, and the JSON content is decoded.
• Error Handling: If the request fails, an error message is generated with details on the failure.

Ensure you have the necessary R packages installed to run this script successfully.

curl -X GET "http://localhost:8000/api/V1/get_peaks/2022/hg38/all/chr5:100000-150000/target/CTCF;FOXA1" -H "Content-Type: application/json"

Explanation:

• curl Command: This example uses the curl command-line tool to make an HTTP GET request to the API endpoint.
• Request Method: The -X GET option specifies that this is a GET request.
• Headers: The -H "Content-Type: application/json" option sets the appropriate request header for JSON content.

Run this command in your terminal to fetch data from the ReMap API.

wget -q --header="Content-Type: application/json" "http://localhost:8000/api/V1/get_peaks/2022/hg38/all/chr5:100000-150000/target/CTCF;FOXA1" -O -

Explanation:

• wget Command: This example uses the wget command-line tool to make an HTTP GET request to the API endpoint.
• Request Options: The -q option runs wget in quiet mode, and --header="Content-Type: application/json" sets the appropriate request header for JSON content.
• Output: The -O - option directs wget to output the response to the terminal.

Use this command in your terminal to retrieve data from the ReMap API efficiently.

#!/usr/bin/perl
use strict;
use warnings;
use LWP::UserAgent;
use JSON;

my $verbose = 0;

# Initialize UserAgent for HTTP requests
my $ua = LWP::UserAgent->new;
$ua->timeout(10);

# Disable SSL verification (for testing purposes)
$ua->ssl_opts(verify_hostname => 0, SSL_verify_mode => 0x00);

# UCSC API endpoint for cCREs
my $ucsc_url = "https://api.genome.ucsc.edu/getData/track?genome=hg38;track=encodeCcreCombined;chrom=chr1;start=1470000;end=1480000";

# Fetch cCREs from UCSC
my $response = $ua->get($ucsc_url);
if ($response->is_success) {
    my $content = $response->decoded_content;
    my $ccres_json = decode_json($content);

    # Print cCREs data for debugging
    print "UCSC cCRE Data:\n" if $verbose;
    print to_json($ccres_json, { pretty => 1 }) if $verbose;

    # Check if cCREs data is available
    unless (exists $ccres_json->{encodeCcreCombined} && @{$ccres_json->{encodeCcreCombined}}) {
        die "No cCREs found in the response.";
    }

    # Loop through each cCRE and fetch ReMap peaks within this region
    foreach my $ccre (@{$ccres_json->{encodeCcreCombined}}) {
        my $chrom = $ccre->{chrom};
        my $start = $ccre->{chromStart};
        my $end = $ccre->{chromEnd};
        my $ucsc_label = $ccre->{ucscLabel};
        my $description = $ccre->{description};

        # Print extracted values along with ucscLabel and description
        print "\n\ncCRE: Chromosome: $chrom, Start: $start, End: $end\n";
        print "UCSC Label: $ucsc_label\n";
        print "Description: $description\n";

        # Prepare ReMap API URL
        my $remap_url = "http://localhost:8000/api/V1/get_peaks/2022/hg38/all/$chrom:$start-$end";

        print "ReMap API URL: $remap_url\n";  # Debug URL

        # Fetch ReMap peaks within cCRE
        my $remap_response = $ua->get($remap_url);
        if ($remap_response->is_success) {
            my $remap_content = $remap_response->decoded_content;
            my $remap_json = decode_json($remap_content);

            # Print fetched ReMap peaks for debugging
            print "ReMap Peaks Data:\n" if $verbose;
            print to_json($remap_json, { pretty => 1 }) if $verbose;

            # Check if ReMap peaks data is available
            unless (exists $remap_json->{peaks} && @{$remap_json->{peaks}}) {
                warn "No peaks found in the ReMap response for cCRE: $chrom:$start-$end";
                next;
            }

            # Loop through each ReMap peak within the cCRE region
            foreach my $peak (@{$remap_json->{peaks}}) {
                my $peak_chrom = $peak->{peakValues}{chrom};
                my $peak_start = $peak->{peakValues}{chromStart};
                my $peak_end = $peak->{peakValues}{chromEnd};
                my $experiment = $peak->{peakValues}{name}{data}{Experiment};
                my $tf = $peak->{peakValues}{name}{data}{TF};
                my $biotype = $peak->{peakValues}{name}{data}{Biotype};

                # Create BED format (chrom, start, end, name, score, strand)
                my $name = join(":", $experiment, $tf, $biotype);
                my $score = ".";  # Default score (can be adjusted based on your needs)
                my $strand = ".";  # Strand information (set as '.' if unknown)

                # Print the BED formatted line
                print "$peak_chrom\t$peak_start\t$peak_end\t$name\t$score\t$strand\n";
            }

        } else {
            warn "Failed to fetch ReMap data: " . $remap_response->status_line;
        }
    }
} else {
    die "Failed to fetch UCSC cCRE data: " . $response->status_line;
}