bossalabs 0.1.0__tar.gz

bossalabs-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: bossalabs
+Version: 0.1.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: boto3
+Requires-Dist: requests
+Requires-Dist: fire
+Requires-Dist: tomli; python_version < "3.11"
+Requires-Dist: requests-toolbelt>=1.0.0
+Requires-Dist: mypy
+Requires-Dist: ruff
+Requires-Dist: pytest
+Requires-Dist: types-requests
+Requires-Dist: tqdm>=4.67.3
+Requires-Dist: python-dotenv>=1.2.2
+
+[![python](https://img.shields.io/badge/python-3.13-blue?logo=python)](https://www.python.org/)
+[![CI](https://github.com/computervisionsports/bossa-client/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/computervisionsports/bossa-client/actions/workflows/ci.yml)
+
+# BossaLabs Python Client
+
+Small Python client for requesting upload authorization and uploading
+video files using a presigned S3 POST.
+
+## Installation
+
+```bash
+uv venv .venv
+source .venv/bin/activate
+uv pip install -e .
+```
+
+Or with plain pip:
+
+```bash
+pip install -e .
+```
+
+Or from PyPI:
+
+```bash
+pip install bossalabs
+```
+
+## Python usage
+
+```python
+from bossalabs import Client
+
+client = Client(
+    api_key="YOUR_API_KEY",
+    model="MODEL_NAME"
+)
+
+result = client.upload_video("/path/to/video.mp4")
+print(result)
+```
+
+## CLI usage
+
+After installation, you can run:
+
+```bash
+bossalabs process-video "/path/to/video.mp4" "MODEL_NAME" --api_key "YOUR_API_KEY"
+```
+
+## Documentation
+
+Full documentation is built with [MkDocs](https://www.mkdocs.org/) and
+[Material for MkDocs](https://squidfunk.github.io/mkdocs-material/).
+
+### Install documentation dependencies
+
+```bash
+uv sync --group docs
+```
+
+### Serve docs locally
+
+Preview the site with live reload:
+
+```bash
+uv run mkdocs serve
+```
+
+Open [http://127.0.0.1:8000](http://127.0.0.1:8000) in your browser.
+
+### Build static HTML
+
+Generate the static site into the `site/` directory:
+
+```bash
+uv run mkdocs build
+```
+
+The HTML output is written to `site/` (gitignored). Deploy that folder to any
+static hosting provider.
+
+### What is documented
+
+The docs cover the public user-facing API:
+
+- `bossalabs.Client` — authorize and upload video files
+- `bossalabs.UploadClientError` — authorization failure type
+- `bossalabs.API_BASE_URL` — default API endpoint constant
+- `bossalabs` CLI — `process-video` command
+
+Internal modules (`bossalabs.models`, scripts, and private helpers) are
+excluded from the API reference.

bossalabs-0.1.0/README.md

@@ -0,0 +1,93 @@
+[![python](https://img.shields.io/badge/python-3.13-blue?logo=python)](https://www.python.org/)
+[![CI](https://github.com/computervisionsports/bossa-client/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/computervisionsports/bossa-client/actions/workflows/ci.yml)
+
+# BossaLabs Python Client
+
+Small Python client for requesting upload authorization and uploading
+video files using a presigned S3 POST.
+
+## Installation
+
+```bash
+uv venv .venv
+source .venv/bin/activate
+uv pip install -e .
+```
+
+Or with plain pip:
+
+```bash
+pip install -e .
+```
+
+Or from PyPI:
+
+```bash
+pip install bossalabs
+```
+
+## Python usage
+
+```python
+from bossalabs import Client
+
+client = Client(
+    api_key="YOUR_API_KEY",
+    model="MODEL_NAME"
+)
+
+result = client.upload_video("/path/to/video.mp4")
+print(result)
+```
+
+## CLI usage
+
+After installation, you can run:
+
+```bash
+bossalabs process-video "/path/to/video.mp4" "MODEL_NAME" --api_key "YOUR_API_KEY"
+```
+
+## Documentation
+
+Full documentation is built with [MkDocs](https://www.mkdocs.org/) and
+[Material for MkDocs](https://squidfunk.github.io/mkdocs-material/).
+
+### Install documentation dependencies
+
+```bash
+uv sync --group docs
+```
+
+### Serve docs locally
+
+Preview the site with live reload:
+
+```bash
+uv run mkdocs serve
+```
+
+Open [http://127.0.0.1:8000](http://127.0.0.1:8000) in your browser.
+
+### Build static HTML
+
+Generate the static site into the `site/` directory:
+
+```bash
+uv run mkdocs build
+```
+
+The HTML output is written to `site/` (gitignored). Deploy that folder to any
+static hosting provider.
+
+### What is documented
+
+The docs cover the public user-facing API:
+
+- `bossalabs.Client` — authorize and upload video files
+- `bossalabs.UploadClientError` — authorization failure type
+- `bossalabs.API_BASE_URL` — default API endpoint constant
+- `bossalabs` CLI — `process-video` command
+
+Internal modules (`bossalabs.models`, scripts, and private helpers) are
+excluded from the API reference.

bossalabs-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "bossalabs"
+version = "0.1.0"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "boto3",
+    "requests",
+    "fire",
+    "tomli; python_version < '3.11'",
+    "requests-toolbelt>=1.0.0",
+    "mypy",
+    "ruff",
+    "pytest",
+    "types-requests",
+    "tqdm>=4.67.3",
+    "python-dotenv>=1.2.2",
+]
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project.scripts]
+bossalabs = "bossalabs.cli.main:main"
+
+[dependency-groups]
+docs = [
+    "mkdocs>=1.6",
+    "mkdocs-material>=9.5",
+    "mkdocstrings[python]>=0.27",
+]

bossalabs-0.1.0/setup.cfg

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

bossalabs-0.1.0/src/bossalabs/__init__.py

@@ -0,0 +1,29 @@
+"""Public API for the BossaLabs Python client.
+
+Import the client module to authorize and upload videos::
+
+    from bossalabs import client
+
+    c = client.Client(api_key="...", model="...")
+    result = c.upload_video("video.mp4")
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+
+from bossalabs.client import Client
+from bossalabs.constants import API_BASE_URL
+from bossalabs.errors import UploadClientError
+
+from . import client
+
+__version__ = version("bossalabs")
+
+__all__ = [
+    "client",
+    "Client",
+    "UploadClientError",
+    "API_BASE_URL",
+    "__version__",
+]

bossalabs-0.1.0/src/bossalabs/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI package for bossalabs commands."""

bossalabs-0.1.0/src/bossalabs/cli/main.py

@@ -0,0 +1,95 @@
+"""Command-line interface for uploading videos to BossaLabs."""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from bossalabs.client import Client
+
+
+def _print_banner() -> None:
+    """Print a compact CLI banner."""
+    print("=" * 54)
+    print("🎬 BossaLabs Video Processor")
+    print("=" * 54)
+
+
+def _print_success(result: dict[str, object]) -> None:
+    """Print success message with formatted payload."""
+    print("✅ Video processed successfully.")
+    print(f"Model: {result.get('model')}")
+    print(
+        f"🚨 IMPORTANT: Your Job ID is: [{result.get('job_id')}] "
+        "You need this ID to request the results."
+    )
+    print(json.dumps(result, indent=2))
+
+
+def _print_error(message: str) -> None:
+    """Print a formatted failure message."""
+    print(f"❌ Video processing failed: {message}")
+
+
+def _process_video(args: argparse.Namespace) -> int:
+    """Upload a video and print the result.
+
+    Returns:
+        ``0`` on success, ``1`` when the upload fails.
+    """
+    video_path = args.video_path
+    api_key = args.api_key
+    model = args.model
+
+    if not video_path:
+        raise ValueError("video_path is required")
+    if not api_key:
+        raise ValueError("api_key is required")
+    if not model:
+        raise ValueError("model is required")
+
+    _print_banner()
+    client = Client(api_key=api_key, model=model)
+    result = client.upload_video(video_path)
+
+    if result.get("success", False) is False:
+        error_message = str(result.get("error", "Some error occurred."))
+        _print_error(error_message)
+        return 1
+
+    _print_success(result)
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the ``bossalabs`` argument parser and subcommands."""
+    parser = argparse.ArgumentParser(prog="bossalabs")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    process_video = subparsers.add_parser("process-video")
+    process_video.add_argument("video_path")
+    process_video.add_argument("model")
+    process_video.add_argument("--api_key", required=True)
+
+    return parser
+
+
+def main() -> int:
+    """Run the ``bossalabs`` CLI.
+
+    Returns:
+        ``0`` on success, ``1`` on upload failure, ``2`` for an unknown
+        command.
+    """
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if args.command == "process-video":
+        return _process_video(args)
+
+    parser.error(f"Unknown command: {args.command}")
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

bossalabs-0.1.0/src/bossalabs/client.py

@@ -0,0 +1,254 @@
+"""BossaLabs API client for authorizing and uploading video files."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, metadata, version
+from pathlib import Path
+import socket
+from typing import Any
+
+import requests  # type: ignore[import-untyped]
+from requests_toolbelt.multipart.encoder import MultipartEncoder  # type: ignore[import-untyped]
+from requests_toolbelt.multipart.encoder import MultipartEncoderMonitor  # type: ignore[import-untyped]
+from tqdm import tqdm
+from bossalabs.errors import UploadClientError
+from bossalabs.models import UploadAuthorization
+import tomllib as toml
+from bossalabs.constants import ALLOWED_VIDEO_EXTENSIONS, API_BASE_URL
+
+
+def _load_package_info() -> tuple[str, str]:
+    """Load package name/version from metadata or pyproject fallback."""
+    distribution_name = "bossalabs"
+    try:
+        package_version = version(distribution_name)
+        package_metadata = metadata(distribution_name)
+        package_name = package_metadata.get("Name", distribution_name)
+        return package_name, package_version
+    except PackageNotFoundError:
+        pyproject_path = Path(__file__).resolve().parents[2] / "pyproject.toml"
+        pyproject_data = toml.loads(pyproject_path.read_text(encoding="utf-8"))
+        project_data = pyproject_data["project"]
+        return str(project_data["name"]), str(project_data["version"])
+
+
+PACKAGE_NAME, PACKAGE_VERSION = _load_package_info()
+
+
+class Client:
+    """Upload videos to BossaLabs via presigned S3 POST.
+
+    Authorizes uploads through the BossaLabs API, then transfers the file with
+    ``requests``. Failures from :meth:`upload_file` are returned as result
+    dictionaries rather than raised exceptions.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        model: str,
+        connect_timeout: int = 30,
+        upload_timeout: int = 14400,
+    ) -> None:
+        """Create a client for the given API key and model.
+
+        Args:
+            api_key: Sent in the ``x-api-key`` header on every request.
+            model: Model name passed to the upload authorization endpoint.
+            connect_timeout: Seconds to wait for a TCP connection.
+            upload_timeout: Seconds to wait for a response body after
+                connecting (authorization and file upload).
+
+        Raises:
+            ValueError: If ``api_key`` or ``model`` is empty.
+        """
+        if not api_key:
+            raise ValueError("API key is required")
+        if not model:
+            raise ValueError("Model is required")
+
+        self.api_base_url = API_BASE_URL
+        self.api_key = api_key
+        self.model = model
+        self.connect_timeout = connect_timeout
+        self.upload_timeout = upload_timeout
+        self.package_version = PACKAGE_VERSION
+        self.package_name = PACKAGE_NAME
+        self.hostname = socket.gethostname()
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "x-api-key": self.api_key,
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": f"{self.package_name}/{self.package_version} ({self.hostname})",
+            }
+        )
+
+    def _authorize_upload(self) -> UploadAuthorization | UploadClientError:
+        url = f"{self.api_base_url}/upload-videos"
+        response = self.session.post(
+            url,
+            json={"model": self.model},
+            timeout=(self.connect_timeout, self.upload_timeout),
+        )
+
+        if response.status_code != 200:
+            return UploadClientError(
+                message="Upload authorization failed.",
+                status_code=response.status_code,
+                body=response.text,
+            )
+
+        payload = response.json()
+
+        return UploadAuthorization(
+            job_id=payload["job_id"],
+            model=payload["model"],
+            bucket=payload["bucket"],
+            key=payload["key"],
+            expires_in_seconds=int(payload["expires_in_seconds"]),
+            max_upload_size_bytes=int(payload["max_upload_size_bytes"]),
+            max_upload_size_gb=float(payload["max_upload_size_gb"]),
+            upload_url=payload["upload"]["url"],
+            upload_fields=dict(payload["upload"]["fields"]),
+        )
+
+    def upload_video(
+        self,
+        video_path: str | Path,
+        content_type: str = "video/mp4",
+    ) -> dict[str, Any]:
+        """Upload a local video file to S3 using boto3.
+
+        Args:
+            video_path: Local path to the video file that will be uploaded.
+            content_type: MIME type used for uploaded content.
+
+        Returns:
+            A result dictionary. On success, ``success`` is ``True`` and the
+            dict includes ``job_id``, ``model``, ``file_size_bytes``, and
+            ``status_code``. On failure, ``success`` is ``False`` and
+            ``error`` contains a human-readable message; other fields may be
+            ``None``.
+        """
+        path = Path(video_path)
+
+        if path.suffix.lower() not in ALLOWED_VIDEO_EXTENSIONS:
+            return {
+                "job_id": None,
+                "model": None,
+                "file_size_bytes": None,
+                "status_code": None,
+                "success": False,
+                "error": f"File extension not allowed: {path.suffix}",
+            }
+
+        if not path.exists():
+            return {
+                "job_id": None,
+                "model": None,
+                "file_size_bytes": None,
+                "status_code": None,
+                "success": False,
+                "error": f"File not found: {path}",
+            }
+
+        if not path.is_file():
+            return {
+                "job_id": None,
+                "model": None,
+                "file_size_bytes": None,
+                "status_code": None,
+                "success": False,
+                "error": f"Path is not a file: {path}",
+            }
+
+        auth = self._authorize_upload()
+        if isinstance(auth, UploadClientError):
+            return {
+                "job_id": None,
+                "model": None,
+                "file_size_bytes": None,
+                "status_code": None,
+                "success": False,
+                "error": auth.message,
+            }
+
+        file_size = path.stat().st_size
+        if file_size > auth.max_upload_size_bytes:
+            return {
+                "job_id": None,
+                "model": None,
+                "file_size_bytes": file_size,
+                "status_code": None,
+                "success": False,
+                "error": f"File too large. size={file_size} bytes, max={auth.max_upload_size_bytes} bytes",
+            }
+
+        final_content_type = content_type or "application/octet-stream"
+
+        fields = dict(auth.upload_fields)
+
+        if "Content-Type" not in fields:
+            fields["Content-Type"] = final_content_type
+
+        try:
+            with path.open("rb") as f:
+                multipart_fields = {
+                    **fields,
+                    "file": (path.name, f, final_content_type),
+                }
+
+                encoder = MultipartEncoder(fields=multipart_fields)
+
+                with tqdm(
+                    total=encoder.len,
+                    unit="B",
+                    unit_scale=True,
+                    unit_divisor=1024,
+                    desc=f"Uploading {path.name}",
+                ) as progress_bar:
+                    last_bytes_read = 0
+
+                    def callback(monitor: MultipartEncoderMonitor) -> None:
+                        nonlocal last_bytes_read
+                        progress_bar.update(monitor.bytes_read - last_bytes_read)
+                        last_bytes_read = monitor.bytes_read
+
+                    monitor = MultipartEncoderMonitor(encoder, callback)
+
+                    response = requests.post(
+                        auth.upload_url,
+                        data=monitor,
+                        headers={"Content-Type": monitor.content_type},
+                        timeout=(self.connect_timeout, self.upload_timeout),
+                    )
+
+            if response.status_code not in (200, 201, 204):
+                return {
+                    "job_id": None,
+                    "model": None,
+                    "file_size_bytes": file_size,
+                    "status_code": response.status_code,
+                    "success": False,
+                    "error": response.text,
+                }
+
+        except requests.RequestException as error:
+            return {
+                "job_id": None,
+                "model": None,
+                "file_size_bytes": file_size,
+                "status_code": None,
+                "success": False,
+                "error": str(error),
+            }
+
+        return {
+            "job_id": auth.job_id,
+            "model": auth.model,
+            "file_size_bytes": file_size,
+            "status_code": response.status_code,
+            "success": True,
+        }

bossalabs-0.1.0/src/bossalabs/constants.py

@@ -0,0 +1,18 @@
+"""Base URL for the BossaLabs API."""
+
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+ENV = os.getenv("ENV", "DEV")
+
+if ENV == "DEV":
+    API_BASE_URL = "https://3q6tjso3ce.execute-api.us-east-1.amazonaws.com/DEV"
+elif ENV == "PROD":
+    API_BASE_URL = "https://3q6tjso3ce.execute-api.us-east-1.amazonaws.com/"
+else:
+    raise ValueError(f"Invalid environment: {ENV}")
+
+
+ALLOWED_VIDEO_EXTENSIONS = [".mp4", ".mov", ".avi", ".mkv", ".webm"]

bossalabs-0.1.0/src/bossalabs/errors.py

@@ -0,0 +1,24 @@
+"""Error types used by the BossaLabs client."""
+
+from __future__ import annotations
+
+
+class UploadClientError(Exception):
+    """Error returned when upload authorization fails.
+
+    :class:`~bossalabs.client.Client` returns this from internal
+    authorization calls. :meth:`~bossalabs.client.Client.upload_file`
+    converts it into a failure result dictionary instead of raising.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status_code: int | None = None,
+        body: str | None = None,
+    ) -> None:
+        self.message = message
+        self.status_code = status_code
+        self.body = body
+        super().__init__(message)

bossalabs-0.1.0/src/bossalabs/models.py

@@ -0,0 +1,33 @@
+"""Data models for BossaLabs API responses."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class AwsCredentials:
+    """Temporary AWS credentials for direct S3 access.
+
+    Not used by the current upload flow, which relies on presigned POST URLs.
+    """
+
+    access_key_id: str
+    secret_access_key: str
+    session_token: str | None = None
+    region: str | None = None
+
+
+@dataclass
+class UploadAuthorization:
+    """Presigned upload details returned by the BossaLabs API."""
+
+    job_id: str
+    model: str
+    bucket: str
+    key: str
+    expires_in_seconds: int
+    max_upload_size_bytes: int
+    max_upload_size_gb: float
+    upload_url: str
+    upload_fields: dict[str, str]

bossalabs-0.1.0/src/bossalabs/scripts/upload_video.py

@@ -0,0 +1,32 @@
+"""Fire-based script entry point for uploading a single video file."""
+
+from __future__ import annotations
+
+from bossalabs.client import Client
+
+
+def main(
+    api_key: str,
+    upload_video_path: str,
+    model: str,
+    content_type: str = "video/mp4",
+) -> dict[str, object]:
+    """Upload a video file via :class:`~bossalabs.client.Client`.
+
+    Args:
+        api_key: API key used for authorization requests.
+        upload_video_path: Local path of the file to upload.
+        model: Model name to use for processing the video.
+        content_type: MIME type sent with the uploaded file.
+
+    Returns:
+        Upload result payload returned by `Client.upload_video`.
+    """
+    client = Client(api_key=api_key, model=model)
+    return client.upload_video(upload_video_path, content_type=content_type)
+
+
+if __name__ == "__main__":
+    import fire
+
+    fire.Fire(main)

bossalabs-0.1.0/src/bossalabs.egg-info/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: bossalabs
+Version: 0.1.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: boto3
+Requires-Dist: requests
+Requires-Dist: fire
+Requires-Dist: tomli; python_version < "3.11"
+Requires-Dist: requests-toolbelt>=1.0.0
+Requires-Dist: mypy
+Requires-Dist: ruff
+Requires-Dist: pytest
+Requires-Dist: types-requests
+Requires-Dist: tqdm>=4.67.3
+Requires-Dist: python-dotenv>=1.2.2
+
+[![python](https://img.shields.io/badge/python-3.13-blue?logo=python)](https://www.python.org/)
+[![CI](https://github.com/computervisionsports/bossa-client/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/computervisionsports/bossa-client/actions/workflows/ci.yml)
+
+# BossaLabs Python Client
+
+Small Python client for requesting upload authorization and uploading
+video files using a presigned S3 POST.
+
+## Installation
+
+```bash
+uv venv .venv
+source .venv/bin/activate
+uv pip install -e .
+```
+
+Or with plain pip:
+
+```bash
+pip install -e .
+```
+
+Or from PyPI:
+
+```bash
+pip install bossalabs
+```
+
+## Python usage
+
+```python
+from bossalabs import Client
+
+client = Client(
+    api_key="YOUR_API_KEY",
+    model="MODEL_NAME"
+)
+
+result = client.upload_video("/path/to/video.mp4")
+print(result)
+```
+
+## CLI usage
+
+After installation, you can run:
+
+```bash
+bossalabs process-video "/path/to/video.mp4" "MODEL_NAME" --api_key "YOUR_API_KEY"
+```
+
+## Documentation
+
+Full documentation is built with [MkDocs](https://www.mkdocs.org/) and
+[Material for MkDocs](https://squidfunk.github.io/mkdocs-material/).
+
+### Install documentation dependencies
+
+```bash
+uv sync --group docs
+```
+
+### Serve docs locally
+
+Preview the site with live reload:
+
+```bash
+uv run mkdocs serve
+```
+
+Open [http://127.0.0.1:8000](http://127.0.0.1:8000) in your browser.
+
+### Build static HTML
+
+Generate the static site into the `site/` directory:
+
+```bash
+uv run mkdocs build
+```
+
+The HTML output is written to `site/` (gitignored). Deploy that folder to any
+static hosting provider.
+
+### What is documented
+
+The docs cover the public user-facing API:
+
+- `bossalabs.Client` — authorize and upload video files
+- `bossalabs.UploadClientError` — authorization failure type
+- `bossalabs.API_BASE_URL` — default API endpoint constant
+- `bossalabs` CLI — `process-video` command
+
+Internal modules (`bossalabs.models`, scripts, and private helpers) are
+excluded from the API reference.

bossalabs-0.1.0/src/bossalabs.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+src/bossalabs/__init__.py
+src/bossalabs/client.py
+src/bossalabs/constants.py
+src/bossalabs/errors.py
+src/bossalabs/models.py
+src/bossalabs.egg-info/PKG-INFO
+src/bossalabs.egg-info/SOURCES.txt
+src/bossalabs.egg-info/dependency_links.txt
+src/bossalabs.egg-info/entry_points.txt
+src/bossalabs.egg-info/requires.txt
+src/bossalabs.egg-info/top_level.txt
+src/bossalabs/cli/__init__.py
+src/bossalabs/cli/main.py
+src/bossalabs/scripts/__init__.py
+src/bossalabs/scripts/upload_video.py
+tests/test_client.py

bossalabs-0.1.0/src/bossalabs.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bossalabs-0.1.0/src/bossalabs.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bossalabs = bossalabs.cli.main:main

bossalabs-0.1.0/src/bossalabs.egg-info/requires.txt

@@ -0,0 +1,13 @@
+boto3
+requests
+fire
+requests-toolbelt>=1.0.0
+mypy
+ruff
+pytest
+types-requests
+tqdm>=4.67.3
+python-dotenv>=1.2.2
+
+[:python_version < "3.11"]
+tomli

bossalabs-0.1.0/src/bossalabs.egg-info/top_level.txt

@@ -0,0 +1 @@
+bossalabs

bossalabs-0.1.0/tests/test_client.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from bossalabs import client
+
+
+class DummySession:
+    """Minimal requests.Session test double."""
+
+    def __init__(self) -> None:
+        self.headers: dict[str, str] = {}
+
+
+def test_create_client_object_with_mocked_session(monkeypatch) -> None:
+    """Creates a client object without real network dependencies."""
+
+    monkeypatch.setattr("bossalabs.client.requests.Session", DummySession)
+
+    c = client.Client(api_key="test-api-key", model="my-dummy-model")
+
+    assert c.api_key == "test-api-key"
+    assert c.model == "my-dummy-model"
+    assert c.session.headers["x-api-key"] == "test-api-key"
+    assert c.session.headers["Accept"] == "application/json"