quantjourney-common-sdk 0.1.1__tar.gz

quantjourney_common_sdk-0.1.1/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: quantjourney-common-sdk
+Version: 0.1.1
+Summary: Shared transport and contract mechanics for QuantJourney SDKs.
+Author: QuantJourney
+License-Expression: LicenseRef-Proprietary
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Provides-Extra: frames
+Requires-Dist: pandas>=2.0.0; extra == "frames"
+
+# quantjourney-common-sdk
+
+Shared Python mechanics for QJ SDKs.
+
+This package owns only transport-level concerns: auth/token exchange, HTTP
+request handling, response envelopes, pagination helpers, bounded retry, and
+small typed models. Domain clients live in SDK-specific packages such as
+`qj.data` and `qj.api`.
+
+Canonical package metadata:
+
+| Field | Value |
+| --- | --- |
+| Repository | `_repo_qj_common_sdk` |
+| Distribution | `quantjourney-common-sdk` |
+| Python import | `qj.common` |
+| Version | `0.1.1` |
+| Git tag | `v0.1.1` |
+| Namespace style | PEP 420 namespace package |
+
+`quantjourney-common-sdk` must not ship `qj/__init__.py`. It is designed to
+co-install with `quantjourney-data` and `quantjourney-api`.
+
+Install from PyPI:
+
+```bash
+pip install quantjourney-common-sdk==0.1.1
+```
+
+No private Python package registry is required. Consumers should pin a compatible
+release range in application dependencies.
+
+Auth model:
+
+- `QJ_*_TOKEN` is sent as a Bearer token directly.
+- `QJ_*_API_KEY=QJ_live_*` is exchanged through `qj-auth /auth/token`.
+- `QJ_*_CLIENT_ID` + `QJ_*_CLIENT_SECRET=QJ_svc_*` use `client_credentials`.
+- exchanged JWTs are cached in memory until shortly before `exp`.
+
+Transport model:
+
+- idempotent reads retry `429/502/503/504` with bounded backoff;
+- each request gets `X-QJ-Request-ID`;
+- response envelopes are parsed into `QJResponse`.

quantjourney_common_sdk-0.1.1/README.md

@@ -0,0 +1,44 @@
+# quantjourney-common-sdk
+
+Shared Python mechanics for QJ SDKs.
+
+This package owns only transport-level concerns: auth/token exchange, HTTP
+request handling, response envelopes, pagination helpers, bounded retry, and
+small typed models. Domain clients live in SDK-specific packages such as
+`qj.data` and `qj.api`.
+
+Canonical package metadata:
+
+| Field | Value |
+| --- | --- |
+| Repository | `_repo_qj_common_sdk` |
+| Distribution | `quantjourney-common-sdk` |
+| Python import | `qj.common` |
+| Version | `0.1.1` |
+| Git tag | `v0.1.1` |
+| Namespace style | PEP 420 namespace package |
+
+`quantjourney-common-sdk` must not ship `qj/__init__.py`. It is designed to
+co-install with `quantjourney-data` and `quantjourney-api`.
+
+Install from PyPI:
+
+```bash
+pip install quantjourney-common-sdk==0.1.1
+```
+
+No private Python package registry is required. Consumers should pin a compatible
+release range in application dependencies.
+
+Auth model:
+
+- `QJ_*_TOKEN` is sent as a Bearer token directly.
+- `QJ_*_API_KEY=QJ_live_*` is exchanged through `qj-auth /auth/token`.
+- `QJ_*_CLIENT_ID` + `QJ_*_CLIENT_SECRET=QJ_svc_*` use `client_credentials`.
+- exchanged JWTs are cached in memory until shortly before `exp`.
+
+Transport model:
+
+- idempotent reads retry `429/502/503/504` with bounded backoff;
+- each request gets `X-QJ-Request-ID`;
+- response envelopes are parsed into `QJResponse`.

quantjourney_common_sdk-0.1.1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quantjourney-common-sdk"
+version = "0.1.1"
+description = "Shared transport and contract mechanics for QuantJourney SDKs."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "QuantJourney" }]
+license = "LicenseRef-Proprietary"
+dependencies = [
+  "requests>=2.31.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.0.0",
+]
+frames = [
+  "pandas>=2.0.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["qj.*"]
+namespaces = true
+
+[tool.pytest.ini_options]
+testpaths = ["_tests"]

quantjourney_common_sdk-0.1.1/qj/common/__init__.py

@@ -0,0 +1,19 @@
+"""Shared mechanics for QuantJourney SDK packages."""
+
+from .auth import AuthConfig
+from .client import HttpClient
+from .errors import QJAPIError, QJAuthError, QJConnectionError, QJError
+from .models import QJResponse
+from .pagination import collect_rows, iter_offset_pages
+
+__all__ = [
+    "AuthConfig",
+    "HttpClient",
+    "QJAPIError",
+    "QJAuthError",
+    "QJConnectionError",
+    "QJError",
+    "QJResponse",
+    "collect_rows",
+    "iter_offset_pages",
+]

quantjourney_common_sdk-0.1.1/qj/common/auth.py

@@ -0,0 +1,158 @@
+"""Authentication helpers shared by QJ SDKs."""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import time
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+import requests
+
+from .errors import QJAuthError
+
+DEFAULT_AUTH_URL = "https://auth.quantjourney.cloud"
+
+
+@dataclass
+class AuthConfig:
+    """Bearer/API-key auth configuration for SDK HTTP clients.
+
+    If a bearer token is available it is sent directly. If only a durable
+    `QJ_live_*` user API key or `QJ_svc_*` service credential is available, the
+    SDK exchanges it through qj-auth and caches the short-lived JWT in memory.
+    """
+
+    bearer_token: str | None = None
+    api_key: str | None = None
+    client_id: str | None = None
+    client_secret: str | None = None
+    auth_url: str = DEFAULT_AUTH_URL
+    tenant_id: str | None = None
+    team_id: str | None = None
+    token_skew_seconds: int = 30
+    exchange_timeout: float = 15.0
+    _cached_token: str | None = None
+    _cached_token_exp: int | None = None
+
+    @classmethod
+    def from_env(cls, prefix: str = "QJ_DATA") -> "AuthConfig":
+        prefix = prefix.rstrip("_")
+        bearer_token = (
+            os.getenv(f"{prefix}_TOKEN")
+            or os.getenv("QJ_API_TOKEN")
+            or os.getenv("QJ_TOKEN")
+        )
+        api_key = (
+            os.getenv(f"{prefix}_API_KEY")
+            or os.getenv("QJ_API_KEY")
+        )
+        return cls(
+            bearer_token=bearer_token,
+            api_key=api_key,
+            client_id=os.getenv(f"{prefix}_CLIENT_ID") or os.getenv("QJ_CLIENT_ID"),
+            client_secret=os.getenv(f"{prefix}_CLIENT_SECRET") or os.getenv("QJ_CLIENT_SECRET"),
+            auth_url=(
+                os.getenv(f"{prefix}_AUTH_URL")
+                or os.getenv("QJ_AUTH_URL")
+                or DEFAULT_AUTH_URL
+            ),
+            tenant_id=os.getenv(f"{prefix}_TENANT_ID") or os.getenv("QJ_TENANT_ID"),
+            team_id=os.getenv(f"{prefix}_TEAM_ID") or os.getenv("QJ_TEAM_ID"),
+        )
+
+    def headers(self) -> Mapping[str, str]:
+        headers: dict[str, str] = {}
+        token = self.token()
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+        if self.tenant_id:
+            headers["X-QJ-Tenant-ID"] = self.tenant_id
+        if self.team_id:
+            headers["X-QJ-Team-ID"] = self.team_id
+        return headers
+
+    def token(self) -> str | None:
+        """Return a bearer token, exchanging durable credentials if needed."""
+        if self.bearer_token:
+            return self.bearer_token
+        if self._cached_token and self._cached_token_is_valid():
+            return self._cached_token
+        if self.api_key:
+            return self.exchange_user_api_key()
+        if self.client_id and self.client_secret:
+            return self.exchange_client_credentials()
+        return None
+
+    def invalidate(self) -> None:
+        """Drop the cached exchanged token."""
+        self._cached_token = None
+        self._cached_token_exp = None
+
+    def exchange_user_api_key(self) -> str:
+        """Exchange a `QJ_live_*` user API key for a short-lived JWT."""
+        return self._exchange(
+            {
+                "grant_type": "urn:quantjourney:api_key",
+                "api_key": self.api_key,
+            }
+        )
+
+    def exchange_client_credentials(self) -> str:
+        """Exchange `QJ_svc_*` service credentials for a short-lived JWT."""
+        return self._exchange(
+            {
+                "grant_type": "client_credentials",
+                "client_id": self.client_id,
+                "client_secret": self.client_secret,
+            }
+        )
+
+    def _exchange(self, payload: Mapping[str, Any]) -> str:
+        url = f"{self.auth_url.rstrip('/')}/auth/token"
+        try:
+            response = requests.post(url, json=dict(payload), timeout=self.exchange_timeout)
+        except requests.RequestException as exc:
+            raise QJAuthError(f"Could not reach qj-auth at {url}: {exc}") from exc
+
+        try:
+            body = response.json()
+        except ValueError as exc:
+            raise QJAuthError(f"qj-auth returned non-JSON response: HTTP {response.status_code}") from exc
+
+        if response.status_code >= 400:
+            detail = body.get("detail") if isinstance(body, dict) else None
+            raise QJAuthError(f"qj-auth token exchange failed: HTTP {response.status_code}: {detail or body}")
+
+        token = body.get("access_token") if isinstance(body, dict) else None
+        if not token:
+            raise QJAuthError("qj-auth token exchange response did not include access_token")
+
+        self._cached_token = str(token)
+        self._cached_token_exp = _jwt_exp(self._cached_token)
+        return self._cached_token
+
+    def _cached_token_is_valid(self) -> bool:
+        if not self._cached_token:
+            return False
+        if not self._cached_token_exp:
+            return True
+        return int(time.time()) < self._cached_token_exp - self.token_skew_seconds
+
+
+def _jwt_exp(token: str) -> int | None:
+    """Return JWT exp without verifying the signature."""
+    parts = token.split(".")
+    if len(parts) < 2:
+        return None
+    payload = parts[1]
+    padding = "=" * (-len(payload) % 4)
+    try:
+        decoded = base64.urlsafe_b64decode((payload + padding).encode("ascii"))
+        data = json.loads(decoded.decode("utf-8"))
+    except Exception:
+        return None
+    exp = data.get("exp")
+    return int(exp) if isinstance(exp, (int, float)) else None

quantjourney_common_sdk-0.1.1/qj/common/client.py

@@ -0,0 +1,154 @@
+"""Small HTTP client used by QJ SDK packages."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+import time
+from typing import Any
+from uuid import uuid4
+
+import requests
+
+from .auth import AuthConfig
+from .errors import QJAPIError, QJConnectionError
+from .models import QJResponse
+
+
+class HttpClient:
+    """Requests-based HTTP client with QJ response envelope handling."""
+
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        auth: AuthConfig | None = None,
+        timeout: float = 30.0,
+        user_agent: str = "qj.common/0.1.0",
+        session: requests.Session | None = None,
+        max_retries: int = 2,
+        backoff_factor: float = 0.25,
+        retry_statuses: set[int] | None = None,
+        retry_methods: set[str] | None = None,
+        sleep=time.sleep,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.auth = auth or AuthConfig()
+        self.timeout = timeout
+        self.user_agent = user_agent
+        self.session = session or requests.Session()
+        self.max_retries = max_retries
+        self.backoff_factor = backoff_factor
+        self.retry_statuses = retry_statuses or {429, 502, 503, 504}
+        self.retry_methods = retry_methods or {"GET", "HEAD", "OPTIONS"}
+        self.sleep = sleep
+
+    def get(
+        self,
+        path: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> QJResponse:
+        return self.request("GET", path, params=params, headers=headers)
+
+    def post(
+        self,
+        path: str,
+        *,
+        json: Mapping[str, Any] | None = None,
+        params: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> QJResponse:
+        return self.request("POST", path, params=params, json=json, headers=headers)
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        json: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> QJResponse:
+        method = method.upper()
+        attempts = self.max_retries + 1 if method in self.retry_methods else 1
+        last_error: requests.RequestException | None = None
+
+        for attempt in range(attempts):
+            request_headers = {
+                "Accept": "application/json",
+                "User-Agent": self.user_agent,
+                "X-QJ-Request-ID": uuid4().hex,
+            }
+            request_headers.update(self.auth.headers())
+            if headers:
+                request_headers.update(headers)
+
+            try:
+                response = self.session.request(
+                    method,
+                    self._url(path),
+                    params=_clean(params),
+                    json=json,
+                    headers=request_headers,
+                    timeout=self.timeout,
+                )
+            except requests.RequestException as exc:
+                last_error = exc
+                if attempt + 1 >= attempts:
+                    raise QJConnectionError(str(exc)) from exc
+                self._sleep_before_retry(attempt, None)
+                continue
+
+            payload = _decode_payload(response)
+            if response.status_code < 400:
+                return QJResponse.from_payload(
+                    payload,
+                    status_code=response.status_code,
+                    headers=dict(response.headers),
+                )
+
+            if response.status_code == 401:
+                self.auth.invalidate()
+
+            if response.status_code in self.retry_statuses and attempt + 1 < attempts:
+                self._sleep_before_retry(attempt, response)
+                continue
+
+            raise QJAPIError.from_response(response.status_code, payload)
+
+        if last_error is not None:
+            raise QJConnectionError(str(last_error)) from last_error
+        raise QJConnectionError("request failed without response")
+
+    def _url(self, path: str) -> str:
+        if path.startswith("http://") or path.startswith("https://"):
+            return path
+        return f"{self.base_url}/{path.lstrip('/')}"
+
+    def _sleep_before_retry(self, attempt: int, response: requests.Response | None) -> None:
+        retry_after = response.headers.get("Retry-After") if response is not None else None
+        if retry_after:
+            try:
+                delay = float(retry_after)
+            except ValueError:
+                delay = self.backoff_factor * (2 ** attempt)
+        else:
+            delay = self.backoff_factor * (2 ** attempt)
+        if delay > 0:
+            self.sleep(delay)
+
+
+def _clean(params: Mapping[str, Any] | None) -> dict[str, Any] | None:
+    if not params:
+        return None
+    return {key: value for key, value in params.items() if value is not None}
+
+
+def _decode_payload(response: requests.Response) -> Any:
+    if not response.text:
+        return {}
+    try:
+        return response.json()
+    except ValueError:
+        return {"raw": response.text}

quantjourney_common_sdk-0.1.1/qj/common/errors.py

@@ -0,0 +1,46 @@
+"""Shared SDK exceptions."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+class QJError(Exception):
+    """Base class for QJ SDK errors."""
+
+
+class QJConnectionError(QJError):
+    """Raised when an SDK cannot reach the configured QJ endpoint."""
+
+
+class QJAuthError(QJError):
+    """Raised when SDK credential exchange or token refresh fails."""
+
+
+@dataclass
+class QJAPIError(QJError):
+    """Raised when QJ returns a non-2xx response."""
+
+    status_code: int
+    message: str
+    ref: str | None = None
+    payload: Any = None
+
+    def __str__(self) -> str:
+        suffix = f" [Ref: {self.ref}]" if self.ref else ""
+        return f"{self.status_code}: {self.message}{suffix}"
+
+    @classmethod
+    def from_response(cls, status_code: int, payload: Any) -> "QJAPIError":
+        message = "QJ API request failed"
+        ref = None
+        if isinstance(payload, dict):
+            detail = payload.get("detail") or payload.get("error") or payload.get("message")
+            if isinstance(detail, dict):
+                message = str(detail.get("message") or detail.get("error") or message)
+                ref = detail.get("ref") or detail.get("request_id")
+            elif detail:
+                message = str(detail)
+            ref = ref or payload.get("ref") or payload.get("request_id")
+        return cls(status_code=status_code, message=message, ref=ref, payload=payload)

quantjourney_common_sdk-0.1.1/qj/common/models.py

@@ -0,0 +1,63 @@
+"""Common response models for QJ SDKs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+@dataclass(frozen=True)
+class QJResponse:
+    """Parsed QJ response envelope.
+
+    QJ services generally return `{meta, data, page}` envelopes. This wrapper
+    keeps the raw payload available while giving SDK users a stable `.data`
+    property for the useful content.
+    """
+
+    data: Any
+    meta: Mapping[str, Any]
+    page: Mapping[str, Any] | None
+    raw: Any
+    status_code: int | None = None
+    headers: Mapping[str, str] | None = None
+
+    @classmethod
+    def from_payload(
+        cls,
+        payload: Any,
+        *,
+        status_code: int | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> "QJResponse":
+        if isinstance(payload, dict):
+            return cls(
+                data=payload.get("data", payload),
+                meta=payload.get("meta", {}),
+                page=payload.get("page"),
+                raw=payload,
+                status_code=status_code,
+                headers=headers,
+            )
+        return cls(data=payload, meta={}, page=None, raw=payload, status_code=status_code, headers=headers)
+
+    def unwrap(self) -> Any:
+        """Return the response data payload."""
+        return self.data
+
+    def to_pandas(self):
+        """Convert list-like data to a pandas DataFrame when pandas is installed."""
+        try:
+            import pandas as pd
+        except ImportError as exc:
+            raise RuntimeError("Install qj-common-sdk[frames] to use to_pandas().") from exc
+
+        if isinstance(self.data, list):
+            return pd.DataFrame(self.data)
+        if isinstance(self.data, dict):
+            for key in ("rows", "items", "results", "assets", "instruments", "signals", "awards", "transactions"):
+                rows = self.data.get(key)
+                if isinstance(rows, list):
+                    return pd.DataFrame(rows)
+            return pd.DataFrame([self.data])
+        return pd.DataFrame(self.data)

quantjourney_common_sdk-0.1.1/qj/common/pagination.py

@@ -0,0 +1,51 @@
+"""Pagination helpers for QJ SDK clients."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterator
+from typing import Any
+
+from .models import QJResponse
+
+
+def iter_offset_pages(
+    fetch_page: Callable[..., QJResponse],
+    *,
+    limit: int = 100,
+    offset_param: str = "offset",
+    limit_param: str = "limit",
+    max_pages: int | None = None,
+    **params: Any,
+) -> Iterator[QJResponse]:
+    """Iterate limit/offset pages until a page returns fewer than `limit` rows."""
+    offset = int(params.pop(offset_param, 0) or 0)
+    pages = 0
+    while True:
+        page = fetch_page(**params, **{limit_param: limit, offset_param: offset})
+        yield page
+        rows = _rows(page.data)
+        pages += 1
+        if max_pages is not None and pages >= max_pages:
+            return
+        if len(rows) < limit:
+            return
+        offset += limit
+
+
+def collect_rows(pages: Iterator[QJResponse]) -> list[Any]:
+    """Collect rows from response pages into a single list."""
+    rows: list[Any] = []
+    for page in pages:
+        rows.extend(_rows(page.data))
+    return rows
+
+
+def _rows(data: Any) -> list[Any]:
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict):
+        for key in ("rows", "items", "results", "assets", "instruments", "signals", "awards", "transactions"):
+            value = data.get(key)
+            if isinstance(value, list):
+                return value
+    return []

quantjourney_common_sdk-0.1.1/qj/common/py.typed

@@ -0,0 +1 @@
+

quantjourney_common_sdk-0.1.1/qj/common/telemetry.py

@@ -0,0 +1,15 @@
+"""Small telemetry helpers for SDK request metadata."""
+
+from __future__ import annotations
+
+from uuid import uuid4
+
+
+def request_id() -> str:
+    """Return a correlation id suitable for `X-QJ-Request-ID`."""
+    return uuid4().hex
+
+
+def user_agent(package: str, version: str) -> str:
+    """Return the canonical QJ SDK user-agent token."""
+    return f"{package}/{version}"

quantjourney_common_sdk-0.1.1/quantjourney_common_sdk.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: quantjourney-common-sdk
+Version: 0.1.1
+Summary: Shared transport and contract mechanics for QuantJourney SDKs.
+Author: QuantJourney
+License-Expression: LicenseRef-Proprietary
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Provides-Extra: frames
+Requires-Dist: pandas>=2.0.0; extra == "frames"
+
+# quantjourney-common-sdk
+
+Shared Python mechanics for QJ SDKs.
+
+This package owns only transport-level concerns: auth/token exchange, HTTP
+request handling, response envelopes, pagination helpers, bounded retry, and
+small typed models. Domain clients live in SDK-specific packages such as
+`qj.data` and `qj.api`.
+
+Canonical package metadata:
+
+| Field | Value |
+| --- | --- |
+| Repository | `_repo_qj_common_sdk` |
+| Distribution | `quantjourney-common-sdk` |
+| Python import | `qj.common` |
+| Version | `0.1.1` |
+| Git tag | `v0.1.1` |
+| Namespace style | PEP 420 namespace package |
+
+`quantjourney-common-sdk` must not ship `qj/__init__.py`. It is designed to
+co-install with `quantjourney-data` and `quantjourney-api`.
+
+Install from PyPI:
+
+```bash
+pip install quantjourney-common-sdk==0.1.1
+```
+
+No private Python package registry is required. Consumers should pin a compatible
+release range in application dependencies.
+
+Auth model:
+
+- `QJ_*_TOKEN` is sent as a Bearer token directly.
+- `QJ_*_API_KEY=QJ_live_*` is exchanged through `qj-auth /auth/token`.
+- `QJ_*_CLIENT_ID` + `QJ_*_CLIENT_SECRET=QJ_svc_*` use `client_credentials`.
+- exchanged JWTs are cached in memory until shortly before `exp`.
+
+Transport model:
+
+- idempotent reads retry `429/502/503/504` with bounded backoff;
+- each request gets `X-QJ-Request-ID`;
+- response envelopes are parsed into `QJResponse`.

quantjourney_common_sdk-0.1.1/quantjourney_common_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+qj/common/__init__.py
+qj/common/auth.py
+qj/common/client.py
+qj/common/errors.py
+qj/common/models.py
+qj/common/pagination.py
+qj/common/py.typed
+qj/common/telemetry.py
+quantjourney_common_sdk.egg-info/PKG-INFO
+quantjourney_common_sdk.egg-info/SOURCES.txt
+quantjourney_common_sdk.egg-info/dependency_links.txt
+quantjourney_common_sdk.egg-info/requires.txt
+quantjourney_common_sdk.egg-info/top_level.txt

quantjourney_common_sdk-0.1.1/quantjourney_common_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

quantjourney_common_sdk-0.1.1/quantjourney_common_sdk.egg-info/requires.txt

@@ -0,0 +1,7 @@
+requests>=2.31.0
+
+[dev]
+pytest>=8.0.0
+
+[frames]
+pandas>=2.0.0

quantjourney_common_sdk-0.1.1/quantjourney_common_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+qj

quantjourney_common_sdk-0.1.1/setup.cfg

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