goliath-utils 0.1.1__tar.gz

goliath_utils-0.1.1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: goliath-utils
+Version: 0.1.1
+Summary: Lightweight internal utilities for the Goliath platform
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: ipykernel>=7.2.0
+Requires-Dist: python-dotenv>=1.2.2
+
+# goliath-utils
+
+Lightweight internal utilities for the Goliath platform.
+
+## Install
+
+```bash
+uv add goliath-utils
+```
+
+## S3 Client
+
+A minimal S3 client using httpx — no boto3 required.
+
+```python
+from goliath_utils.s3 import S3Client
+
+# Reads AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION from env
+with S3Client() as s3:
+    s3.create_bucket("my-bucket")
+    s3.upload_file("my-bucket", "data/file.csv", "./file.csv")
+    s3.download_file("my-bucket", "data/file.csv", "./downloaded.csv")
+    keys = s3.list_objects("my-bucket", prefix="data/")
+    s3.delete_bucket("my-bucket")
+```

goliath_utils-0.1.1/README.md

@@ -0,0 +1,25 @@
+# goliath-utils
+
+Lightweight internal utilities for the Goliath platform.
+
+## Install
+
+```bash
+uv add goliath-utils
+```
+
+## S3 Client
+
+A minimal S3 client using httpx — no boto3 required.
+
+```python
+from goliath_utils.s3 import S3Client
+
+# Reads AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION from env
+with S3Client() as s3:
+    s3.create_bucket("my-bucket")
+    s3.upload_file("my-bucket", "data/file.csv", "./file.csv")
+    s3.download_file("my-bucket", "data/file.csv", "./downloaded.csv")
+    keys = s3.list_objects("my-bucket", prefix="data/")
+    s3.delete_bucket("my-bucket")
+```

goliath_utils-0.1.1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "goliath-utils"
+version = "0.1.1"
+description = "Lightweight internal utilities for the Goliath platform"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "httpx>=0.27",
+    "ipykernel>=7.2.0",
+    "python-dotenv>=1.2.2",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[dependency-groups]
+dev = [
+    "build>=1.4.2",
+    "twine>=6.2.0",
+]

goliath_utils-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

goliath_utils-0.1.1/src/goliath_utils/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

goliath_utils-0.1.1/src/goliath_utils/s3/__init__.py

@@ -0,0 +1,4 @@
+from ._client import S3Client
+from ._errors import S3AuthError, S3Error, S3RequestError
+
+__all__ = ["S3Client", "S3Error", "S3AuthError", "S3RequestError"]

goliath_utils-0.1.1/src/goliath_utils/s3/_auth.py

@@ -0,0 +1,133 @@
+"""AWS Signature Version 4 signing — stdlib only."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+from datetime import datetime, timezone
+from urllib.parse import parse_qsl, quote, urlparse
+
+
+def _sha256_hex(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def _uri_encode(value: str, encode_slash: bool = True) -> str:
+    safe = "" if encode_slash else "/"
+    return quote(value, safe=safe)
+
+
+def _canonical_query_string(query: str) -> str:
+    """Parse, URI-encode, and sort query parameters per SigV4 spec."""
+    if not query:
+        return ""
+    params = parse_qsl(query, keep_blank_values=True)
+    encoded = sorted((_uri_encode(k), _uri_encode(v)) for k, v in params)
+    return "&".join(f"{k}={v}" for k, v in encoded)
+
+
+def _derive_signing_key(
+    secret_key: str, date_stamp: str, region: str, service: str
+) -> bytes:
+    k_date = hmac.new(
+        f"AWS4{secret_key}".encode("utf-8"),
+        date_stamp.encode("utf-8"),
+        hashlib.sha256,
+    ).digest()
+    k_region = hmac.new(k_date, region.encode("utf-8"), hashlib.sha256).digest()
+    k_service = hmac.new(k_region, service.encode("utf-8"), hashlib.sha256).digest()
+    k_signing = hmac.new(k_service, b"aws4_request", hashlib.sha256).digest()
+    return k_signing
+
+
+def _make_canonical_request(
+    method: str,
+    path: str,
+    query_string: str,
+    headers: dict[str, str],
+    signed_header_names: str,
+    payload_hash: str,
+) -> str:
+    canonical_headers = ""
+    for name in signed_header_names.split(";"):
+        canonical_headers += f"{name}:{headers[name]}\n"
+
+    return "\n".join([
+        method,
+        _uri_encode(path, encode_slash=False),
+        query_string,
+        canonical_headers,
+        signed_header_names,
+        payload_hash,
+    ])
+
+
+def _make_string_to_sign(
+    datetime_stamp: str,
+    credential_scope: str,
+    canonical_request: str,
+) -> str:
+    return "\n".join([
+        "AWS4-HMAC-SHA256",
+        datetime_stamp,
+        credential_scope,
+        _sha256_hex(canonical_request.encode("utf-8")),
+    ])
+
+
+def sign_request(
+    method: str,
+    url: str,
+    headers: dict[str, str],
+    payload: bytes,
+    *,
+    access_key: str,
+    secret_key: str,
+    region: str,
+    service: str = "s3",
+) -> dict[str, str]:
+    """Sign an HTTP request with AWS SigV4. Returns updated headers dict."""
+    now = datetime.now(timezone.utc)
+    datetime_stamp = now.strftime("%Y%m%dT%H%M%SZ")
+    date_stamp = now.strftime("%Y%m%d")
+
+    parsed = urlparse(url)
+    host = parsed.hostname
+    path = parsed.path or "/"
+    query_string = _canonical_query_string(parsed.query)
+
+    payload_hash = _sha256_hex(payload)
+
+    # Build headers to sign
+    headers = dict(headers)
+    headers["host"] = host
+    headers["x-amz-date"] = datetime_stamp
+    headers["x-amz-content-sha256"] = payload_hash
+
+    signed_header_names = ";".join(sorted(headers.keys()))
+
+    canonical_request = _make_canonical_request(
+        method, path, query_string, headers, signed_header_names, payload_hash
+    )
+
+    credential_scope = f"{date_stamp}/{region}/{service}/aws4_request"
+    string_to_sign = _make_string_to_sign(
+        datetime_stamp, credential_scope, canonical_request
+    )
+
+    signing_key = _derive_signing_key(secret_key, date_stamp, region, service)
+    signature = hmac.new(
+        signing_key, string_to_sign.encode("utf-8"), hashlib.sha256
+    ).hexdigest()
+
+    headers["authorization"] = (
+        f"AWS4-HMAC-SHA256 "
+        f"Credential={access_key}/{credential_scope}, "
+        f"SignedHeaders={signed_header_names}, "
+        f"Signature={signature}"
+    )
+
+    # Remove host header — httpx sets it automatically
+    del headers["host"]
+
+    return headers

goliath_utils-0.1.1/src/goliath_utils/s3/_client.py

@@ -0,0 +1,187 @@
+"""Lightweight S3 client using httpx and AWS SigV4."""
+
+from __future__ import annotations
+
+import os
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+import httpx
+from dotenv import load_dotenv
+
+from ._auth import sign_request
+from ._errors import S3AuthError, S3RequestError
+
+S3_NS = "http://s3.amazonaws.com/doc/2006-03-01/"
+
+
+class S3Client:
+    """Minimal S3 client — no boto3 required.
+
+    Reads credentials from constructor args or environment variables:
+    AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION.
+    """
+
+    def __init__(
+        self,
+        *,
+        access_key: str | None = None,
+        secret_key: str | None = None,
+        region: str | None = None,
+        timeout: float = 30.0,
+    ):
+        load_dotenv()
+
+        self.access_key = access_key or os.environ.get("AWS_ACCESS_KEY_ID", "")
+        self.secret_key = secret_key or os.environ.get("AWS_SECRET_ACCESS_KEY", "")
+        self.region = region or os.environ.get("AWS_REGION", "us-east-1")
+
+        if not self.access_key or not self.secret_key:
+            raise S3AuthError(
+                "AWS credentials required. Set AWS_ACCESS_KEY_ID and "
+                "AWS_SECRET_ACCESS_KEY environment variables, or pass them directly."
+            )
+
+        self._http = httpx.Client(timeout=timeout)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()
+
+    # -- internal helpers --------------------------------------------------
+
+    def _endpoint(self, bucket: str, key: str = "") -> str:
+        path = f"/{key}" if key else "/"
+        return f"https://{bucket}.s3.{self.region}.amazonaws.com{path}"
+
+    def _signed_request(
+        self,
+        method: str,
+        url: str,
+        payload: bytes = b"",
+        extra_headers: dict[str, str] | None = None,
+    ) -> httpx.Response:
+        headers = dict(extra_headers or {})
+        signed = sign_request(
+            method,
+            url,
+            headers,
+            payload,
+            access_key=self.access_key,
+            secret_key=self.secret_key,
+            region=self.region,
+        )
+        resp = self._http.request(method, url, headers=signed, content=payload)
+        if resp.status_code >= 300:
+            self._raise_error(resp)
+        return resp
+
+    @staticmethod
+    def _raise_error(resp: httpx.Response) -> None:
+        code = "Unknown"
+        message = resp.text
+        try:
+            root = ET.fromstring(resp.text)
+            code_el = root.find("Code")
+            msg_el = root.find("Message")
+            if code_el is not None and code_el.text:
+                code = code_el.text
+            if msg_el is not None and msg_el.text:
+                message = msg_el.text
+        except ET.ParseError:
+            pass
+        raise S3RequestError(resp.status_code, code, message)
+
+    # -- public API --------------------------------------------------------
+
+    def create_bucket(self, bucket: str) -> None:
+        url = self._endpoint(bucket)
+        if self.region == "us-east-1":
+            self._signed_request("PUT", url)
+        else:
+            body = (
+                f'<CreateBucketConfiguration xmlns="{S3_NS}">'
+                f"<LocationConstraint>{self.region}</LocationConstraint>"
+                f"</CreateBucketConfiguration>"
+            ).encode()
+            self._signed_request("PUT", url, payload=body)
+
+    def delete_bucket(self, bucket: str) -> None:
+        url = self._endpoint(bucket)
+        self._signed_request("DELETE", url)
+
+    def delete_object(self, bucket: str, key: str) -> None:
+        url = self._endpoint(bucket, key)
+        self._signed_request("DELETE", url)
+
+    def copy_object(
+        self,
+        src_bucket: str,
+        src_key: str,
+        dest_bucket: str,
+        dest_key: str,
+    ) -> None:
+        url = self._endpoint(dest_bucket, dest_key)
+        copy_source = f"/{src_bucket}/{src_key}"
+        self._signed_request(
+            "PUT", url, extra_headers={"x-amz-copy-source": copy_source}
+        )
+
+    def move_object(
+        self,
+        src_bucket: str,
+        src_key: str,
+        dest_bucket: str,
+        dest_key: str,
+    ) -> None:
+        self.copy_object(src_bucket, src_key, dest_bucket, dest_key)
+        self.delete_object(src_bucket, src_key)
+
+    def upload_file(
+        self, bucket: str, key: str, file_path: Path | str
+    ) -> None:
+        file_path = Path(file_path)
+        data = file_path.read_bytes()
+        url = self._endpoint(bucket, key)
+        self._signed_request("PUT", url, payload=data)
+
+    def download_file(
+        self, bucket: str, key: str, dest_path: Path | str
+    ) -> None:
+        dest_path = Path(dest_path)
+        url = self._endpoint(bucket, key)
+        resp = self._signed_request("GET", url)
+        dest_path.parent.mkdir(parents=True, exist_ok=True)
+        dest_path.write_bytes(resp.content)
+
+    def list_objects(self, bucket: str, prefix: str = "") -> list[str]:
+        url = self._endpoint(bucket)
+        keys: list[str] = []
+        continuation_token = ""
+
+        while True:
+            qs = f"list-type=2&prefix={prefix}"
+            if continuation_token:
+                qs += f"&continuation-token={continuation_token}"
+            resp = self._signed_request("GET", f"{url}?{qs}")
+
+            root = ET.fromstring(resp.text)
+            for contents in root.findall(f"{{{S3_NS}}}Contents"):
+                key_el = contents.find(f"{{{S3_NS}}}Key")
+                if key_el is not None and key_el.text:
+                    keys.append(key_el.text)
+
+            is_truncated = root.find(f"{{{S3_NS}}}IsTruncated")
+            if is_truncated is not None and is_truncated.text == "true":
+                token_el = root.find(f"{{{S3_NS}}}NextContinuationToken")
+                if token_el is not None and token_el.text:
+                    continuation_token = token_el.text
+                    continue
+            break
+
+        return keys

goliath_utils-0.1.1/src/goliath_utils/s3/_errors.py

@@ -0,0 +1,16 @@
+class S3Error(Exception):
+    """Base exception for S3 operations."""
+
+
+class S3AuthError(S3Error):
+    """Raised when AWS credentials are missing or invalid."""
+
+
+class S3RequestError(S3Error):
+    """Raised when the S3 API returns a non-2xx response."""
+
+    def __init__(self, status_code: int, code: str, message: str):
+        self.status_code = status_code
+        self.code = code
+        self.message = message
+        super().__init__(f"S3 error {status_code} ({code}): {message}")

goliath_utils-0.1.1/src/goliath_utils/secrets/__init__.py

@@ -0,0 +1,5 @@
+"""Internal secrets access — not yet implemented."""
+
+
+def get_secret(name: str) -> str:
+    raise NotImplementedError("secrets.get_secret is not yet implemented")

goliath_utils-0.1.1/src/goliath_utils.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: goliath-utils
+Version: 0.1.1
+Summary: Lightweight internal utilities for the Goliath platform
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: ipykernel>=7.2.0
+Requires-Dist: python-dotenv>=1.2.2
+
+# goliath-utils
+
+Lightweight internal utilities for the Goliath platform.
+
+## Install
+
+```bash
+uv add goliath-utils
+```
+
+## S3 Client
+
+A minimal S3 client using httpx — no boto3 required.
+
+```python
+from goliath_utils.s3 import S3Client
+
+# Reads AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION from env
+with S3Client() as s3:
+    s3.create_bucket("my-bucket")
+    s3.upload_file("my-bucket", "data/file.csv", "./file.csv")
+    s3.download_file("my-bucket", "data/file.csv", "./downloaded.csv")
+    keys = s3.list_objects("my-bucket", prefix="data/")
+    s3.delete_bucket("my-bucket")
+```

goliath_utils-0.1.1/src/goliath_utils.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/goliath_utils/__init__.py
+src/goliath_utils.egg-info/PKG-INFO
+src/goliath_utils.egg-info/SOURCES.txt
+src/goliath_utils.egg-info/dependency_links.txt
+src/goliath_utils.egg-info/requires.txt
+src/goliath_utils.egg-info/top_level.txt
+src/goliath_utils/s3/__init__.py
+src/goliath_utils/s3/_auth.py
+src/goliath_utils/s3/_client.py
+src/goliath_utils/s3/_errors.py
+src/goliath_utils/secrets/__init__.py

goliath_utils-0.1.1/src/goliath_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

goliath_utils-0.1.1/src/goliath_utils.egg-info/requires.txt

@@ -0,0 +1,3 @@
+httpx>=0.27
+ipykernel>=7.2.0
+python-dotenv>=1.2.2

goliath_utils-0.1.1/src/goliath_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+goliath_utils