Importing Data

var file = Download("<filePathOrURL>");

file = self.download("<filePathOrURL>")

# If your file is in CSV format, convert it to a DataFrame with the `read_csv` method.
from io import StringIO
import pandas as pd
df = pd.read_csv(StringIO(file))

# If your file is in JSON format, parse it with the `loads` method.
import json
data = json.loads(file)

# If your file is in XML format, parse it with the `fromstring` method.
import xml.etree.ElementTree as ET
root = ET.fromstring(file)

var headers = new Dictionary { { "1", "1" } };
Download(address, headers);
Download(address, headers, userName, password);

header = { "1": "1" }
self.download(address, headers)
self.download(address, headers, user_name, password)

import hashlib, hmac
import pandas as pd
from io import StringIO
from datetime import datetime, timezone

class S3DownloadExampleAlgorithm(QCAlgorithm):
    def initialize(self):
        # Read the AWS credentials from project parameters to keep them out of source control.
        access_key = self.get_parameter("aws-access-key-id")
        secret_key = self.get_parameter("aws-secret-access-key")
        region = "us-east-1"
        host = "my-bucket.s3.us-east-1.amazonaws.com"
        key = "path/to/file.csv"

        # Sign the GET request with SigV4 and download the file with the Download method.
        headers = self._sigv4_headers(access_key, secret_key, region, host, key)
        file = self.download(f"https://{host}/{key}", headers)

        # Parse the CSV content into a DataFrame.
        df = pd.read_csv(StringIO(file))
        self.log(f"Downloaded {df.shape[0]} rows")

    def _sigv4_headers(self, access_key, secret_key, region, host, key):
        service = "s3"
        # Use the real UTC time so the request stays within the 15-minute window S3 allows.
        now = datetime.now(timezone.utc)
        amz_date = now.strftime("%Y%m%dT%H%M%SZ")
        date = amz_date[:8]
        # A GET request has no body, so sign the hash of an empty payload.
        payload_hash = hashlib.sha256(b"").hexdigest()

        # Build the canonical request and the string to sign.
        signed_headers = "host;x-amz-content-sha256;x-amz-date"
        canonical_headers = f"host:{host}\nx-amz-content-sha256:{payload_hash}\nx-amz-date:{amz_date}\n"
        canonical_request = f"GET\n/{key}\n\n{canonical_headers}\n{signed_headers}\n{payload_hash}"
        scope = f"{date}/{region}/{service}/aws4_request"
        string_to_sign = f"AWS4-HMAC-SHA256\n{amz_date}\n{scope}\n{hashlib.sha256(canonical_request.encode()).hexdigest()}"

        # Derive the signing key and sign the request.
        signing_key = ("AWS4" + secret_key).encode()
        for part in [date, region, service, "aws4_request"]:
            signing_key = hmac.new(signing_key, part.encode(), hashlib.sha256).digest()
        signature = hmac.new(signing_key, string_to_sign.encode(), hashlib.sha256).hexdigest()

        authorization = f"AWS4-HMAC-SHA256 Credential={access_key}/{scope}, SignedHeaders={signed_headers}, Signature={signature}"
        return {"x-amz-date": amz_date, "x-amz-content-sha256": payload_hash, "Authorization": authorization}

using System.Security.Cryptography;

public class S3DownloadExampleAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        // Read the AWS credentials from project parameters to keep them out of source control.
        var accessKey = GetParameter("aws-access-key-id");
        var secretKey = GetParameter("aws-secret-access-key");
        var region = "us-east-1";
        var host = "my-bucket.s3.us-east-1.amazonaws.com";
        var key = "path/to/file.csv";

        // Sign the GET request with SigV4 and download the file with the Download method.
        var headers = SignV4(accessKey, secretKey, region, host, key);
        var file = Download($"https://{host}/{key}", headers);
        Log(file.Substring(0, Math.Min(200, file.Length)));
    }

    private Dictionary<string, string> SignV4(string accessKey, string secretKey, string region, string host, string key)
    {
        var service = "s3";
        // A GET request has no body, so sign the hash of an empty payload.
        var payloadHash = ToHex(SHA256.HashData(Array.Empty<byte>()));
        // Use the real UTC time so the request stays within the 15-minute window S3 allows.
        var now = DateTime.UtcNow;
        var amzDate = now.ToString("yyyyMMddTHHmmssZ");
        var date = now.ToString("yyyyMMdd");

        // Build the canonical request and the string to sign.
        var signedHeaders = "host;x-amz-content-sha256;x-amz-date";
        var canonicalHeaders = $"host:{host}\nx-amz-content-sha256:{payloadHash}\nx-amz-date:{amzDate}\n";
        var canonicalRequest = $"GET\n/{key}\n\n{canonicalHeaders}\n{signedHeaders}\n{payloadHash}";
        var scope = $"{date}/{region}/{service}/aws4_request";
        var stringToSign = $"AWS4-HMAC-SHA256\n{amzDate}\n{scope}\n{ToHex(SHA256.HashData(Encoding.UTF8.GetBytes(canonicalRequest)))}";

        // Derive the signing key and sign the request.
        var signingKey = Encoding.UTF8.GetBytes("AWS4" + secretKey);
        foreach (var part in new[] { date, region, service, "aws4_request" })
        {
            signingKey = HMACSHA256.HashData(signingKey, Encoding.UTF8.GetBytes(part));
        }
        var signature = ToHex(HMACSHA256.HashData(signingKey, Encoding.UTF8.GetBytes(stringToSign)));

        var authorization = $"AWS4-HMAC-SHA256 Credential={accessKey}/{scope}, SignedHeaders={signedHeaders}, Signature={signature}";
        return new Dictionary<string, string>
        {
            { "x-amz-date", amzDate },
            { "x-amz-content-sha256", payloadHash },
            { "Authorization", authorization }
        };
    }

    private static string ToHex(byte[] bytes) => Convert.ToHexString(bytes).ToLowerInvariant();
}