curious-pyapi 0.1.0__tar.gz → 0.1.2__tar.gz

{curious_pyapi-0.1.0 → curious_pyapi-0.1.2}/.github/workflows/publish_to_pypi.yaml

@@ -16,17 +16,17 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
         with:
           fetch-depth: 0  # Full git history required for uv-dynamic-versioning
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
 
       - name: Set up Python 3.14
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v7
         with:
           python-version: "3.14"
 

curious_pyapi-0.1.2/.markdownlint.yaml

@@ -0,0 +1,5 @@
+# line length
+MD013: false
+# no duplicate headers
+MD024:
+  siblings_only: true

curious_pyapi-0.1.2/.vscode/settings.json

@@ -0,0 +1,9 @@
+{
+  "python-envs.pythonProjects": [
+    {
+      "path": ".",
+      "envManager": "ms-python.python:venv",
+      "packageManager": "ms-python.python:pip"
+    }
+  ]
+}

{curious_pyapi-0.1.0 → curious_pyapi-0.1.2}/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.2]
+
+### Added
+
+- Badges to README.
+
+## [0.1.1]
+
+### Added
+
+- Push account to Curious method.
+- Create new Curious user method.
+- Accept Curious invitation method.
+
 ## [0.1.0]
 
 ### Added

{curious_pyapi-0.1.0 → curious_pyapi-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: curious-pyapi
-Version: 0.1.0
+Version: 0.1.2
 Summary: Python interface for Curious API.
 Author-email: Jon Cluce <jon.clucas@childmind.org>
 License-File: LICENSE

{curious_pyapi-0.1.0 → curious_pyapi-0.1.2}/pyproject.toml

@@ -20,3 +20,19 @@ dependencies = [
 
 [tool.hatch.version]
 source = "uv-dynamic-versioning"
+
+[tool.pyright]
+reportUnknownMemberType = false
+
+[tool.ruff]
+line-length = 88
+target-version = "py314"
+
+[tool.ruff.lint]
+extend-select = ["A", "B904", "C4", "D", "E", "EM", "F541", "G", "I", "ICN", "LOG007", "N", "NPY", "PL", "RET", "RSE", "RUF", "Q", "T20", "TRY002", "TRY201", "TRY400", "TRY401", "UP032", "W"]
+ignore = ["D203", "D212", "RUF002", "RUF003"]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+force-sort-within-sections = true
+order-by-type = false

curious_pyapi-0.1.2/src/curious_pyapi/api/curious.py

@@ -0,0 +1,335 @@
+"""Curious API functionality."""
+
+import json
+from typing import Any, Optional
+
+import httpx
+import polars as pl
+from pydantic import AnyHttpUrl, SecretStr
+
+from ..exceptions import ApiStatusError, AuthenticationError, CuriousApiError
+from ..schema.curious import CuriousId, NewUserData, Record
+from ..schema.pyapi import ApiClient, CuriousAuth, EndpointPath, Tokens, url
+from ..utils.data import api_data
+from ..utils.defaults import CURIOUS_BASE_URL, headers
+from ..utils.logging import get_logger
+
+LOGGER = get_logger(__name__)
+
+
+class CuriousApiClient(ApiClient):
+    """API Client managing authentication, connection pooling, and endpoint routing."""
+
+    # Declarative Endpoints
+    applets = EndpointPath("/applets")
+    applet_by_id = EndpointPath("/applets/{applet_id}")
+    auth_login = EndpointPath("/auth/login")
+    invite_user = EndpointPath("/invitations/{applet_id}/{user_type}")
+    invitations = EndpointPath("/invitations")
+    invitation_accept = EndpointPath("/invitations/{key}/accept")
+
+    me = EndpointPath("/users/me")
+    user_create = EndpointPath("/users")
+
+    def __init__(
+        self,
+        *,
+        auth: Optional[CuriousAuth] = None,
+        base_url: httpx.URL | AnyHttpUrl = CURIOUS_BASE_URL,
+    ) -> None:
+        """Initialize Curious API Client."""
+        self.base_url = httpx.URL(str(base_url))
+        self._tokens: Optional[Tokens] = None
+        self._auth_header: Optional[str] = None
+        self._my_name: Optional[str] = None
+        self._applets: dict[str, Applet] = {}
+
+        # Always initialize a valid client instance
+        self._client = httpx.Client(
+            base_url=str(self.base_url),
+            follow_redirects=True,
+            event_hooks={
+                "request": [self._inject_auth_header],
+                "build": [self._inject_auth_header],
+            },
+        )
+
+        if auth:
+            self.authenticate(auth)
+            # Pre-load applets only after successful authentication
+            self.get_applets(refresh=True)
+
+    def __str__(self) -> str:
+        """Return string representation of Curious API client without side-effects."""
+        name_str = self._my_name if self._my_name else "Unauthenticated"
+        return f"CuriousApiClient({name_str})"
+
+    def __repr__(self) -> str:
+        """Return reproducible string without triggering network calls."""
+        name_str = f'"{self._my_name}"' if self._my_name else "None"
+        return f'CuriousApiClient(name={name_str}, base_url="{self.base_url}")'
+
+    def fetch_name(self) -> str:
+        """Fetch and return the user's name from the API."""
+        me = self.me.get()
+        me_json = me.json().get("result", {})
+
+        first = me_json.get("firstName", "")
+        last = me_json.get("lastName", "")
+        self._my_name = " ".join(filter(None, [first, last]))
+        return self._my_name
+
+    @property
+    def my_name(self) -> str:
+        """Return memoized string name, fetching only if authenticated and missing."""
+        if self._my_name is None:
+            if self.is_authenticated:
+                self.fetch_name()
+            else:
+                return "Unauthenticated"
+        assert isinstance(self._my_name, str)
+        return self._my_name
+
+    def _inject_auth_header(self, request: httpx.Request) -> None:
+        """Event hook executed right before any request is sent over the wire."""
+        if self._auth_header:
+            request.headers["Authorization"] = self._auth_header
+
+    def get_applets(self, refresh: bool = False) -> None:
+        """Gather bound Applets into a dict."""
+        if not refresh and self._applets:
+            return
+
+        applets: "dict[str, Applet]" = {}
+        result = self.applets.get().json().get("result", [])
+        for applet in result:
+            if {"displayName", "id"}.issubset(applet):
+                applets[applet["displayName"]] = Applet(
+                    self, applet["id"], display_name=applet["displayName"]
+                )
+        self._applets = applets
+
+    @property
+    def is_authenticated(self) -> bool:
+        """Return True if the client is authenticated."""
+        return self._auth_header is not None
+
+    def authenticate(self, auth: CuriousAuth) -> None:
+        """Authenticate immediately and store Bearer token."""
+        tokens = self._fetch_tokens(auth.login_credentials)
+        if not tokens.access:
+            msg = "Authentication succeeded but accessToken was empty."
+            raise AuthenticationError(msg)
+
+        self._tokens = tokens
+        self._auth_header = f"Bearer {tokens.access.get_secret_value()}"
+        LOGGER.info("Successfully authenticated as Bearer token.")
+
+    def _fetch_tokens(self, credentials: dict[str, str | SecretStr]) -> Tokens:
+        """Post login credentials to obtain tokens."""
+        target_url = str(self.base_url.join(httpx.URL("auth/login")))
+        try:
+            response = httpx.post(
+                target_url,
+                json=api_data(credentials),
+                headers=headers(),
+            )
+
+            if httpx.codes.is_success(response.status_code):
+                data = response.json()
+                token_data = data.get("result", {}).get("token", {})
+                access = token_data.get("accessToken")
+                refresh = token_data.get("refreshToken")
+
+                if not access:
+                    msg = f"Auth response missing 'accessToken': {data}"
+                    raise AuthenticationError(msg)
+
+                return Tokens(access=access, refresh=refresh)
+
+            msg = f"Login failed with status {response.status_code}: {response.text}"
+            raise AuthenticationError(msg)
+
+        except (httpx.HTTPError, json.JSONDecodeError) as e:
+            msg = f"Authentication request failed: {e}"
+            raise AuthenticationError(msg) from e
+
+    def request(
+        self, method: str, path: str | httpx.URL, **kwargs: Any
+    ) -> httpx.Response:
+        """Centralized transport gateway with error mapping and auth checking."""
+        clean_path = str(path).lstrip("/")
+
+        if not self.is_authenticated:
+            LOGGER.warning(
+                "Attempting unauthenticated '%s' request to '%s'", method, clean_path
+            )
+        request = self._client.build_request(method, clean_path, **kwargs)
+        LOGGER.exception(request)
+        try:
+            response = self._client.request(method, clean_path, **kwargs)
+            response.raise_for_status()
+            return response
+        except httpx.HTTPStatusError as e:
+            LOGGER.exception("Sent Headers: %s", dict(e.request.headers))
+            LOGGER.exception("Response Error Details: %s", e.response.text)
+            raise ApiStatusError(
+                str(e.response), request=e.request, response=e.response
+            ) from e
+        except httpx.HTTPError as e:
+            msg = f"Network transport error: {e}"
+            raise CuriousApiError(msg) from e
+
+    def close(self) -> None:
+        """Close internal HTTP connection pool."""
+        self._client.close()
+
+    def create_accounts_from_df(
+        self,
+        df: pl.DataFrame,
+        applet_id: CuriousId,
+        user_type: str = "respondent",
+        *,
+        limit=None,
+    ) -> None:
+        """For each row in DataFrame, create an account in Curious."""
+        _create_accounts_from_df(self, df, applet_id, user_type, limit=limit)
+
+    def __enter__(self) -> CuriousApiClient:
+        """Enter context manager and return self."""
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Exit context manager and close the client."""
+        self.close()
+
+
+class Applet:
+    """Applet bound to a client."""
+
+    def __init__(
+        self,
+        client: CuriousApiClient,
+        applet_id: CuriousId,
+        *,
+        display_name: Optional[str] = None,
+    ) -> None:
+        """Initialize Applet."""
+        self._id = applet_id
+        self._client = client
+        if display_name:
+            self._name = display_name
+        else:
+            self._name = (
+                self._client.applet_by_id(applet_id=applet_id)
+                .get()
+                .json()["result"]["displayName"]
+            )
+
+    def __str__(self) -> str:
+        """Return string representation of Applet."""
+        return f"Applet({self._name})"
+
+    def __repr__(self) -> str:
+        """Return reproducible string representation of Applet."""
+        return (
+            f'Applet(client={self._client}, applet_id="{self._id}", '
+            f'display_name="{self._name}")'
+        )
+
+
+def create_toplevel_user(new_user_data: NewUserData) -> None:
+    """Create a top-level user in Curious."""
+    client = CuriousApiClient()
+    response = client.user_create.post(json=new_user_data)
+    if not httpx.codes.is_success(response.status_code):
+        msg = f"Failed to create user: {response.status_code} - {response.text}"
+        raise ApiStatusError(
+            msg,
+            request=response.request,
+            response=response,
+        )
+
+
+def get_curious_token(
+    curious_data: Record,
+    curious_headers: Optional[Record] = None,
+    curious_url: httpx.URL | AnyHttpUrl = CURIOUS_BASE_URL,
+) -> Optional[Tokens]:
+    """
+    Process the response to a POST request to the specified URL.
+
+    Parameters
+    ----------
+    curious_data
+        The data to include in the POST request.
+    curious_headers
+        The headers to include in the POST request.
+    curious_url
+        The URL to send the POST request to.
+
+    Returns
+    -------
+    Tokens or None
+        An object containing (access, refresh) token strings, or None if unsuccessful.
+
+    Raises
+    ------
+    RuntimeError
+        If there is an error with the request or response.
+
+    """
+    curious_headers = headers(headers=curious_headers)
+    curious_url = url(curious_url)
+    try:
+        # Sending the POST request
+        response = httpx.post(
+            curious_url.join("/auth/login"),
+            json=api_data(curious_data),
+            headers=curious_headers,
+        )
+        if httpx.codes.is_success(response.status_code):
+            response_data = response.json()
+            access_token = (
+                response_data.get("result", {})
+                .get("token", {})
+                .get("accessToken", None)
+            )  # Get access token
+            refresh_token = (
+                response_data.get("result", {})
+                .get("token", {})
+                .get("refreshToken", None)
+            )  # Get refresh token
+        else:
+            LOGGER.exception(
+                "Failed to fetch data: %d - %s", response.status_code, response.text
+            )
+            response.raise_for_status()
+            return None
+
+        return Tokens(access=access_token, refresh=refresh_token)
+
+    except httpx.HTTPError as e:
+        msg = f"Error sending request: {e}"
+        raise RuntimeError(msg) from e
+    except json.JSONDecodeError as e:
+        msg = f"Error: Response is not valid JSON! {e}"
+        raise RuntimeError(msg) from e
+
+
+def create_accounts_from_df(
+    client: CuriousApiClient,
+    df: pl.DataFrame,
+    applet_id: CuriousId,
+    user_type: str = "respondent",
+    *,
+    limit=None,
+) -> None:
+    """For each row in DataFrame, create an account in Curious."""
+    if limit:
+        df = df.head(limit)
+    for record in df.to_dicts():
+        client.invite_user(applet_id=applet_id, user_type=user_type).post(json=record)
+
+
+_create_accounts_from_df = create_accounts_from_df

curious_pyapi-0.1.2/src/curious_pyapi/exceptions/__init__.py

@@ -0,0 +1,5 @@
+"""Exceptions."""
+
+from .exceptions import ApiStatusError, AuthenticationError, CuriousApiError
+
+__all__ = ["ApiStatusError", "AuthenticationError", "CuriousApiError"]

curious_pyapi-0.1.2/src/curious_pyapi/exceptions/exceptions.py

@@ -0,0 +1,66 @@
+"""Custom exceptions and exception handling."""
+
+import json
+from typing import Any, Callable
+
+from httpx import codes, HTTPStatusError, RequestError, Response
+
+
+def allow_existing(
+    post: Callable[[], Response], *, warn_if_existing: bool = True, **kwargs: Any
+) -> Response | None:
+    """Post, but allow existing."""
+    try:
+        response = post(**kwargs)
+    except Exception as e:
+        if hasattr(e, "response"):
+            _response = getattr(e, "response")
+            if getattr(_response, "status_code") == codes.BAD_REQUEST:
+                results = getattr(_response, "json")().get("result", [])
+                if results:
+                    if isinstance(results[0], dict):
+                        _request = getattr(e, "request")
+                        warning: tuple[str, ...]
+                        message = results[0].get("message")
+                        match message:
+                            case (
+                                "That email address is already associated "
+                                "with a Curious account."
+                            ):
+                                warning = (
+                                    "%s is already associated with a Curious account.",
+                                    str(
+                                        json.loads(
+                                            getattr(_request, "content", json.dumps({}))
+                                        ).get("email", "That email address")
+                                    ),
+                                )
+                            case "Non-unique value.":
+                                warning = (
+                                    (
+                                        "A record with the same unique "
+                                        "value already exists."
+                                    ),
+                                )
+                            case _:
+                                raise
+                        if warn_if_existing:
+                            from ..utils.logging import get_logger  # noqa: PLC0415
+
+                            logger = get_logger(__name__)
+                            logger.warning(*warning)
+                        return None
+        raise
+    return response
+
+
+class ApiStatusError(HTTPStatusError):
+    """Raised when an API request returns a non-successful status code."""
+
+
+class AuthenticationError(RequestError):
+    """Raised when authentication fails."""
+
+
+class CuriousApiError(RequestError):
+    """Raised for general Curious API errors."""

curious_pyapi-0.1.2/src/curious_pyapi/schema/curious.py

@@ -0,0 +1,108 @@
+"""Curious schemas."""
+
+from collections.abc import Mapping
+from typing import Annotated
+
+import polars as pl
+from pydantic.types import StringConstraints
+
+from ..utils.logging import get_logger
+from .regex import EMAIL_REGEX
+
+LOGGER = get_logger(__name__)
+
+
+type IntStr = int | str
+"""Integer or integers string."""
+type IntStrContainer = list[IntStr] | set[IntStr] | tuple[IntStr, ...]
+"""Iterable container of integers and/or integers strings."""
+type Record = (
+    dict[str, IntStr | IntStrContainer] | Mapping[str, IntStr | IntStrContainer]
+)
+"""Dictionary/mapping with string keys and IntStr or IntStrContainer values."""
+
+
+def _validate(
+    df: pl.DataFrame, schema: pl.Schema, required_cols: list[str]
+) -> pl.DataFrame:
+    """Validate DataFrame, adding missing columns with nulls and casting types."""
+    exprs = [
+        pl.col(col).cast(dtype)
+        if col in df.columns
+        else pl.lit(None, dtype=dtype).alias(col)
+        for col, dtype in schema.items()
+    ]
+
+    out_df = df.select(exprs)
+
+    # Evaluate against out_df where 'email' is guaranteed to exist
+    is_valid_email = pl.col("email").str.contains(EMAIL_REGEX).fill_null(False)
+
+    failures_df = out_df.filter(~is_valid_email)
+    out_df = out_df.filter(is_valid_email)
+
+    if not failures_df.is_empty():
+        log_cols = [col for col in required_cols if col in failures_df.columns]
+        LOGGER.error(
+            "Dropped %d records due to invalid email addresses:\n%s",
+            failures_df.height,
+            failures_df.select(log_cols),
+        )
+
+    return out_df
+
+
+@pl.api.register_dataframe_namespace("curious_account")
+class CuriousAccount:
+    """Curious account invitation."""
+
+    SCHEMA = pl.Schema(
+        {
+            "email": pl.String,
+            "firstName": pl.String,
+            "lastName": pl.String,
+            "language": pl.String,
+            "secretUserId": pl.String,
+            "nickname": pl.String,
+            "tag": pl.String,
+        }
+    )
+
+    def __init__(self, df: pl.DataFrame):
+        """Initialize CuriousAccount."""
+        self._df = df
+
+    def enforce_schema(self) -> pl.DataFrame:
+        """Enforces schema, adds missing columns with nulls, and casts types."""
+        return _validate(self._df, self.SCHEMA, ["email", "secretUserId", "nickname"])
+
+
+CuriousId = Annotated[
+    str,
+    StringConstraints(pattern=r"^[a-zA-Z0-9]{8}(-[a-zA-Z0-9]{4}){3}-[a-zA-Z0-9]{12}$"),
+]
+"""ID string for a Curious entity."""
+
+
+@pl.api.register_dataframe_namespace("new_curious_user")
+class NewUserData:
+    """Required data for creating a new Curious user account."""
+
+    SCHEMA = pl.Schema(
+        {
+            "email": pl.String,
+            "firstName": pl.String,
+            "lastName": pl.String,
+            "password": pl.String,
+        }
+    )
+
+    def __init__(self, df: pl.DataFrame):
+        """Initialize NewUserData."""
+        self._df = df
+
+    def enforce_schema(self) -> pl.DataFrame:
+        """Enforces schema, adds missing columns with nulls, and casts types."""
+        return _validate(
+            self._df, self.SCHEMA, ["email", "firstName", "lastName", "password"]
+        )

curious_pyapi-0.1.2/src/curious_pyapi/schema/pyapi.py

@@ -0,0 +1,116 @@
+"""Curious-PyAPI schemas."""
+
+from typing import Any, Optional, overload
+
+from httpx import Response, URL
+from pydantic import AnyHttpUrl, BaseModel, EmailStr, SecretStr
+
+from ..utils.logging import get_logger
+from .curious import CuriousId
+
+logger = get_logger(__name__)
+
+
+class CuriousAuth(BaseModel):
+    """Required data for authentication and decryption."""
+
+    curious_email: EmailStr
+    curious_password: SecretStr
+    applet_id: Optional[CuriousId] = None
+    applet_password: Optional[SecretStr] = None
+
+    @property
+    def login_credentials(self) -> dict[str, str | SecretStr]:
+        """Return email and password as dictionary for API request."""
+        return {"email": self.curious_email, "password": self.curious_password}
+
+
+class ApiClient:
+    """Generic API client."""
+
+    base_url: URL
+
+    def request(self, method: str, path: str | URL, **kwargs: Any) -> Response:
+        """Centralized transport gateway with error mapping and auth checking."""
+        return NotImplemented()
+
+
+class BoundEndpoint:
+    """Class to bind endpoint to an instance."""
+
+    def __init__(self, client: ApiClient, path: str) -> None:
+        """Initialize bound endpoint."""
+        self._client = client
+        self.path = path
+
+    def __call__(self, **kwargs: Any) -> "BoundEndpoint":
+        """Allow calling endpoint as a function to format path parameters."""
+        return BoundEndpoint(self._client, self.path.format(**kwargs))
+
+    @property
+    def url(self) -> URL:
+        """Return base URL."""
+        return self._client.base_url.join(URL(self.path.lstrip("/")))
+
+    def get(self, **kwargs: Any) -> Response:
+        """Return GET response."""
+        return self._client.request("GET", self.path, **kwargs)
+
+    def post(self, **kwargs: Any) -> Response:
+        """Return POST response."""
+        return self._client.request("POST", self.path, **kwargs)
+
+
+class EndpointPath:
+    """Endpoint path or full URL."""
+
+    def __init__(self, path: str) -> None:
+        """Initialize endpoint path."""
+        self.path = path
+
+    @overload
+    def __get__(self, instance: None, owner: Any) -> str: ...
+
+    @overload
+    def __get__(self, instance: ApiClient, owner: Any) -> BoundEndpoint: ...
+
+    def __get__(self, instance: Optional[ApiClient], owner: Any) -> str | BoundEndpoint:
+        """Return path or bound endpoint."""
+        if instance is None:
+            return self.path
+        return BoundEndpoint(instance, self.path)
+
+
+class Endpoint:
+    """API endpoint."""
+
+    auth = EndpointPath("/auth/login")
+
+    def __init__(self, base_url: URL | AnyHttpUrl) -> None:
+        """Initialize API endpoint."""
+        self._base_url = url(base_url)
+
+    @property
+    def base_url(self) -> URL:
+        """Return base URL for API endpoint."""
+        return self._base_url
+
+    @base_url.setter
+    def base_url(self, value: URL) -> None:
+        """Update base URL for API endpoint."""
+        self._base_url = value
+
+
+class Tokens(BaseModel):
+    """Curious tokens."""
+
+    access: SecretStr
+    refresh: SecretStr
+
+
+def url(url: URL | AnyHttpUrl) -> URL:
+    """Typecheck and cast to `httpx.URL`."""
+    if isinstance(url, str):
+        url = URL(url)
+    assert isinstance(url, URL)
+    return url

{curious_pyapi-0.1.0 → curious_pyapi-0.1.2}/src/curious_pyapi/utils/data.py

@@ -2,8 +2,10 @@
 
 from pydantic import SecretStr
 
+from ..schema.curious import Record
 
-def api_data(data: dict) -> dict:
+
+def api_data(data: Record | dict[str, str | SecretStr]) -> Record:
     """Prep data for API calls."""
     return {
         k: v.get_secret_value() if isinstance(v, SecretStr) else v

{curious_pyapi-0.1.0 → curious_pyapi-0.1.2}/src/curious_pyapi/utils/defaults.py

@@ -4,13 +4,19 @@ from typing import Optional
 
 from httpx import URL
 
+from ..schema.curious import Record
+
 CURIOUS_BASE_URL = URL("https://api-v2.gettingcurious.com")
 """Canonical URL for Curious API."""
 
 
 def headers(
-    token: Optional[str] = None, headers: Optional[dict] = None
+    token: Optional[str] = None, headers: Optional[Record] = None
 ) -> dict[str, str]:
     """Return Curious headers."""
     auth = {"Authorization": f"Bearer {token}"} if token else {}
-    return {"Content-Type": "application/json"} | auth | (headers or {})
+    return (
+        {"Content-Type": "application/json"}
+        | auth
+        | ({k: str(v) for k, v in headers.items()} if headers else {})
+    )

{curious_pyapi-0.1.0 → curious_pyapi-0.1.2}/uv.lock

@@ -171,7 +171,7 @@ wheels = [
 
 [[package]]
 name = "pydantic"
-version = "2.13.4"
+version = "2.13.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "annotated-types" },
@@ -179,9 +179,9 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "typing-inspection" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/ef/fc4f868f4e2cee79f863883abffceff107875f569b848507319842d2a681/pydantic-2.13.5.tar.gz", hash = "sha256:51a9c5f7b2f8e636f04c6cada605d9b6a3bf1348fdf945a3d8869b19bba0ee08", size = 845750, upload-time = "2026-08-28T14:04:00.916Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/47/c95ffc2009878c7aac0c5e08528022dcb885933252a88b5f170058014464/pydantic-2.13.5-py3-none-any.whl", hash = "sha256:346a034f080da3755d8e9cb5e00e8b07de1d39e4f6e2c87d8ab7cafa0b269a73", size = 472589, upload-time = "2026-08-28T14:03:59.136Z" },
 ]
 
 [package.optional-dependencies]
@@ -191,43 +191,43 @@ email = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.46.4"
+version = "2.46.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8d/74/228a26ddad29c6672b805d9fd78e8d251cd04004fa7eed0e622096cd0250/pydantic_core-2.46.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:428e04521a40150c85216fc8b85e8d39fece235a9cf5e383761238c7fa9b96fb", size = 2102079, upload-time = "2026-05-06T13:38:41.019Z" },
-    { url = "https://files.pythonhosted.org/packages/ad/1f/8970b150a4b4365623ae00fc88603491f763c627311ae8031e3111356d6e/pydantic_core-2.46.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23ace664830ee0bfe014a0c7bc248b1f7f25ed7ad103852c317624a1083af462", size = 1952179, upload-time = "2026-05-06T13:36:59.812Z" },
-    { url = "https://files.pythonhosted.org/packages/95/30/5211a831ae054928054b2f79731661087a2bc5c01e825c672b3a4a8f1b3e/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce5c1d2a8b27468f433ca974829c44060b8097eedc39933e3c206a90ee49c4a9", size = 1978926, upload-time = "2026-05-06T13:37:39.933Z" },
-    { url = "https://files.pythonhosted.org/packages/57/e9/689668733b1eb67adeef047db3c2e8788fcf65a7fd9c9e2b46b7744fe245/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7283d57845ecf5a163403eb0702dfc220cc4fbdd18919cb5ccea4f95ee1cdab4", size = 2046785, upload-time = "2026-05-06T13:38:01.995Z" },
-    { url = "https://files.pythonhosted.org/packages/60/d9/6715260422ff50a2109878fd24d948a6c3446bb2664f34ee78cd972b3acd/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8daafc69c93ee8a0204506a3b6b30f586ef54028f52aeeeb5c4cfc5184fd5914", size = 2228733, upload-time = "2026-05-06T13:40:50.371Z" },
-    { url = "https://files.pythonhosted.org/packages/18/ae/fdb2f64316afca925640f8e70bb1a564b0ec2721c1389e25b8eb4bf9a299/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd2213145bcc2ba85884d0ac63d222fece9209678f77b9b4d76f054c561adb28", size = 2307534, upload-time = "2026-05-06T13:37:21.531Z" },
-    { url = "https://files.pythonhosted.org/packages/89/1d/8eff589b45bb8190a9d12c49cfad0f176a5cbd1534908a6b5125e2886239/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a5f930472650a82629163023e630d160863fce524c616f4e5186e5de9d9a49b", size = 2099732, upload-time = "2026-05-06T13:39:31.942Z" },
-    { url = "https://files.pythonhosted.org/packages/06/d5/ee5a3366637fee41dee51a1fc91562dcf12ddbc68fda34e6b253da2324bb/pydantic_core-2.46.4-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:c1b3f518abeca3aa13c712fd202306e145abf59a18b094a6bafb2d2bbf59192c", size = 2129627, upload-time = "2026-05-06T13:37:25.033Z" },
-    { url = "https://files.pythonhosted.org/packages/94/33/2414be571d2c6a6c4d08be21f9292b6d3fdb08949a97b6dfe985017821db/pydantic_core-2.46.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a7dd0b3ee80d90150e3495a3a13ac34dbcbfd4f012996a6a1d8900e91b5c0fb", size = 2179141, upload-time = "2026-05-06T13:37:14.046Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/79/7daa95be995be0eecc4cf75064cb33f9bbbfe3fe0158caf2f0d4a996a5c7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:3fb702cd90b0446a3a1c5e470bfa0dd23c0233b676a9099ddcc964fa6ca13898", size = 2184325, upload-time = "2026-05-06T13:36:53.615Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/cb/d0a382f5c0de8a222dc61c65348e0ce831b1f68e0a018450d31c2cace3a5/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b8458003118a712e66286df6a707db01c52c0f52f7db8e4a38f0da1d3b94fc4e", size = 2323990, upload-time = "2026-05-06T13:40:29.971Z" },
-    { url = "https://files.pythonhosted.org/packages/05/db/d9ba624cc4a5aced1598e88c04fdbd8310c8a69b9d38b9a3d39ce3a61ed7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:372429a130e469c9cd698925ce5fc50940b7a1336b0d82038e63d5bbc4edc519", size = 2369978, upload-time = "2026-05-06T13:37:23.027Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/20/d15df15ba918c423461905802bfd2981c3af0bfa0e40d05e13edbfa48bc3/pydantic_core-2.46.4-cp314-cp314-win32.whl", hash = "sha256:85bb3611ff1802f3ee7fdd7dbff26b56f343fb432d57a4728fdd49b6ef35e2f4", size = 1966354, upload-time = "2026-05-06T13:38:03.499Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/b6/6b8de4c0a7d7ab3004c439c80c5c1e0a3e8d78bbae19379b01960383d9e5/pydantic_core-2.46.4-cp314-cp314-win_amd64.whl", hash = "sha256:811ff8e9c313ab425368bcbb36e5c4ebd7108c2bbf4e4089cfbb0b01eff63fac", size = 2072238, upload-time = "2026-05-06T13:39:40.807Z" },
-    { url = "https://files.pythonhosted.org/packages/32/36/51eb763beec1f4cf59b1db243a7dcc39cbb41230f050a09b9d69faaf0a48/pydantic_core-2.46.4-cp314-cp314-win_arm64.whl", hash = "sha256:bfec22eab3c8cc2ceec0248aec886624116dc079afa027ecc8ad4a7e62010f8a", size = 2018251, upload-time = "2026-05-06T13:37:26.72Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/91/855af51d625b23aa987116a19e231d2aaef9c4a415273ddc189b79a45fee/pydantic_core-2.46.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:af8244b2bef6aaad6d92cda81372de7f8c8d36c9f0c3ea36e827c60e7d9467a0", size = 2099593, upload-time = "2026-05-06T13:39:47.682Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/1b/8784a54c65edb5f49f0a14d6977cf1b209bba85a4c77445b255c2de58ab3/pydantic_core-2.46.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a4330cdbc57162e4b3aa303f588ba752257694c9c9be3e7ebb11b4aca659b5d", size = 1935226, upload-time = "2026-05-06T13:40:40.428Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/e7/1955d28d1afc56dd4b3ad7cc0cf39df1b9852964cf16e5d13912756d6d6b/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c61fc04a3d840155ff08e475a04809278972fe6aef51e2720554e96367e34b", size = 1974605, upload-time = "2026-05-06T13:37:32.029Z" },
-    { url = "https://files.pythonhosted.org/packages/93/e2/3fedbf0ba7a22850e6e9fd78117f1c0f10f950182344d8a6c535d468fdd8/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c50f2528cf200c5eed56faf3f4e22fcd5f38c157a8b78576e6ba3168ec35f000", size = 2030777, upload-time = "2026-05-06T13:38:55.239Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/61/46be275fcaaba0b4f5b9669dd852267ce1ff616592dccf7a7845588df091/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cbe8b01f948de4286c74cdd6c667aceb38f5c1e26f0693b3983d9d74887c65e", size = 2236641, upload-time = "2026-05-06T13:37:08.096Z" },
-    { url = "https://files.pythonhosted.org/packages/60/db/12e93e46a8bac9988be3c016860f83293daea8c716c029c9ace279036f2f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:617d7e2ca7dcb8c5cf6bcb8c59b8832c94b36196bbf1cbd1bfb56ed341905edd", size = 2286404, upload-time = "2026-05-06T13:40:20.221Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/4a/4d8b19008f38d31c53b8219cfedc2e3d5de5fe99d90076b7e767de29274f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7027560ee92211647d0d34e3f7cd6f50da56399d26a9c8ad0da286d3869a53f3", size = 2109219, upload-time = "2026-05-06T13:38:12.153Z" },
-    { url = "https://files.pythonhosted.org/packages/88/70/3cbc40978fefb7bb09c6708d40d4ad1a5d70fd7213c3d17f971de868ec1f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:f99626688942fb746e545232e7726926f3be91b5975f8b55327665fafda991c7", size = 2110594, upload-time = "2026-05-06T13:40:02.971Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/20/b8d36736216e29491125531685b2f9e61aa5b4b2599893f8268551da3338/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc3e9034a63de20e15e8ade85358bc6efc614008cab72898b4b4952bea0509ff", size = 2159542, upload-time = "2026-05-06T13:39:27.506Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/a2/367df868eb584dacf6bf82a389272406d7178e301c4ac82545ab98bc2dd9/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:97e7cf2be5c77b7d1a9713a05605d49460d02c6078d38d8bef3cbe323c548424", size = 2168146, upload-time = "2026-05-06T13:38:31.93Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/b8/4460f77f7e201893f649a29ab355dddd3beee8a97bcb1a320db414f9a06e/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:3bf92c5d0e00fefaab325a4d27828fe6b6e2a21848686b5b60d2d9eeb09d76c6", size = 2306309, upload-time = "2026-05-06T13:37:44.717Z" },
-    { url = "https://files.pythonhosted.org/packages/64/c4/be2639293acd87dc8ddbcec41a73cee9b2ebf996fe6d892a1a74e88ad3f7/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:3ecbc122d18468d06ca279dc26a8c2e2d5acb10943bb35e36ae92096dc3b5565", size = 2369736, upload-time = "2026-05-06T13:37:05.645Z" },
-    { url = "https://files.pythonhosted.org/packages/30/a6/9f9f380dbb301f67023bf8f707aaa75daadf84f7152d95c410fd7e81d994/pydantic_core-2.46.4-cp314-cp314t-win32.whl", hash = "sha256:e846ae7835bf0703ae43f534ab79a867146dadd59dc9ca5c8b53d5c8f7c9ef02", size = 1955575, upload-time = "2026-05-06T13:38:51.116Z" },
-    { url = "https://files.pythonhosted.org/packages/40/1f/f1eb9eb350e795d1af8586289746f5c5677d16043040d63710e22abc43c9/pydantic_core-2.46.4-cp314-cp314t-win_amd64.whl", hash = "sha256:2108ba5c1c1eca18030634489dc544844144ee36357f2f9f780b93e7ddbb44b5", size = 2051624, upload-time = "2026-05-06T13:38:21.672Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/af/f9/8a06bea35ef8daf588f707784c973a7046e0034c8d8cfb08828eeffb8b75/pydantic_core-2.46.5.tar.gz", hash = "sha256:10416c15b8839ecc4ef4d0885da76da6fd0f67333a0eb8aff6d93c4b8f2910fc", size = 472262, upload-time = "2026-08-28T10:01:31.677Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8e/8a/14596f2a8367da50cf7cbac48169ee5d9c8e11d486a3b527082384630c72/pydantic_core-2.46.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:c1c43ad4339643d70ebb8124e1305a7dab423001eff58bb41a0f731adbc98355", size = 2074081, upload-time = "2026-08-28T09:59:16.141Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/d5/d8a4eb6d6c7f66b91dd37c576d76e9e60fba900caf5372c17bcf949febc2/pydantic_core-2.46.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1a353f84de772f423b5ffb11d7ae352fbbef0f446f3c0b0af0f8236d7233606e", size = 1920497, upload-time = "2026-08-28T09:59:18.065Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/26/092079428f86e927e030b2c0ced87df69dbb1c875cdeaa67bf42ea2be746/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5086029a57366b8cf81b130a43908738095c270c21a8d7f0e8bdfdb89718e2f3", size = 1952130, upload-time = "2026-08-28T09:59:20.476Z" },
+    { url = "https://files.pythonhosted.org/packages/08/c3/8ec0e290a9ebaebd64047bf5fda94be835c6b1551b02437e4b76778fbcd7/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:46c25dda9d092a06c08db76ffe0a197107904d0dfac653f7d5306bbcd6d6119c", size = 2026371, upload-time = "2026-08-28T09:59:22.227Z" },
+    { url = "https://files.pythonhosted.org/packages/01/72/4fd20ad520fb8da0157f95b27a7eb05a72790ef08138e7701ac972c342ea/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:37ea7b83c935e5b0d68c9449b82651accf78a10828b2c02b2f2d9e9496446c21", size = 2202822, upload-time = "2026-08-28T09:59:24.277Z" },
+    { url = "https://files.pythonhosted.org/packages/31/b0/d16e0771206b29314f0d52198b720be21e8a99ab2bf11e3bc0d7c9cebdff/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e64e88d5585bea9ce95861079de72006c7fa6d3df4e3a3b65ba31eb979c15c9f", size = 2262756, upload-time = "2026-08-28T09:59:26.608Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/9b/59634b7ac631c63b2a37760eb6943af3e29573d6b59a4abc5e7f019d4cee/pydantic_core-2.46.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54d510bac3ee52247af28ed4bb18a1e799f040ac60fd2bf5ccd4c92f1fbe786f", size = 2068352, upload-time = "2026-08-28T09:59:29.044Z" },
+    { url = "https://files.pythonhosted.org/packages/08/7c/570abb1ad2155348dc754ea91be22e5aaa18eb6d69a6068f7c6f2679a6ed/pydantic_core-2.46.5-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:a2a5e1d0ff29adddc9f6d6821a66302e4493f8ca898b715b6b1182c2c201ea0a", size = 2104777, upload-time = "2026-08-28T09:59:30.95Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/25/5bf74adc65a1ac5b7be3f6cb0bcb5433615c1598a801c19d830d84c98ded/pydantic_core-2.46.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:03b9666e41e35d8909852ba191a0607520f81b74eaf12ccf8737005dbb313821", size = 2156312, upload-time = "2026-08-28T09:59:32.604Z" },
+    { url = "https://files.pythonhosted.org/packages/90/6a/2ef38830675e050121040618135564ed56b860b45433b02d9b4ebece46f3/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:a91c17edf6eea2402cb5457b4c89e99bc5ed1004aa34c4adf1d4258c1a5c22c2", size = 2150067, upload-time = "2026-08-28T09:59:34.453Z" },
+    { url = "https://files.pythonhosted.org/packages/90/ef/a7dbb03a14a64c2a4621f989c615ed9a892535a6cad938fc27079f919d80/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b49924c73a235e969511bf2aabdff3beebf9820931f646c80274d5d780010c47", size = 2304516, upload-time = "2026-08-28T09:59:36.194Z" },
+    { url = "https://files.pythonhosted.org/packages/68/f8/6bb4c4b80e8a6fde1904c64a51c62a1d04fcdfa3ea521a66b2ddefa1d885/pydantic_core-2.46.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:2cbd9a5eff05e51c447c34dfa4632145b26b09120cf04bd0c871e44c1a5e1c9a", size = 2335223, upload-time = "2026-08-28T09:59:37.931Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/80/f46b8c681195190b2c1f1c7c0a81abce60663e987613e09ef64d433dd96b/pydantic_core-2.46.5-cp314-cp314-win32.whl", hash = "sha256:2d5d76654becf5efd62c9e51c3756c67b49498b0c9a40884934c40807adbd074", size = 1934827, upload-time = "2026-08-28T09:59:39.836Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/3c/60674207246bc0a4009d2391b7c7251c7159f279c8d2ab8aae8ef46f3dee/pydantic_core-2.46.5-cp314-cp314-win_amd64.whl", hash = "sha256:fa10ef4112775900e7a0661068635eb67b2ab824fbde764de6e0e21982a93db0", size = 2042648, upload-time = "2026-08-28T09:59:41.792Z" },
+    { url = "https://files.pythonhosted.org/packages/69/0c/117c562c7c1babdf44576b72a5e496906506c93690387ecfbca7c729ae2e/pydantic_core-2.46.5-cp314-cp314-win_arm64.whl", hash = "sha256:045ab3b6d308439e32b81cc173bba5b9018bc6ed896afd0c65b3b009b1699af5", size = 1989652, upload-time = "2026-08-28T09:59:43.702Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/66/9336ae58f9eb68c41d121894e52c4c89eccb07eb8f602a04ee9c3f37736a/pydantic_core-2.46.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8816f3d218beb4b787de5c9759c259b8fa61f9dec42dc7811f320a33771778b7", size = 2065829, upload-time = "2026-08-28T09:59:45.364Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/02/bc19b47a96c2d3109760711acf22369e56bd7e405ca52f7ade164d2ead57/pydantic_core-2.46.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:bce57638e08ac148e5778cce7feb968307a727d66f8e2274a543d0cf0c9ad6a3", size = 1905716, upload-time = "2026-08-28T09:59:47.18Z" },
+    { url = "https://files.pythonhosted.org/packages/52/a4/70b47c0509923dd98ccfed04fb3e32ea3849c82a0ff2205bb41009b43c00/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:976e1128455aa595ea04c79ccfedff1aaeab96ee013fcc916bed120c4f0ad94f", size = 1934216, upload-time = "2026-08-28T09:59:49.241Z" },
+    { url = "https://files.pythonhosted.org/packages/52/ab/aa03b65f7bb198585edf806b906c3223ecf1795543e39e23aec4cce27ad2/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b891faeedeafba41b2983e5001a81b6a915b69544c7e7570d1989ce1c36ac7", size = 2010635, upload-time = "2026-08-28T09:59:51.692Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/8b/0da06343f30b84ec549aafd309c6456223d5dc8bd36af504c573faad561d/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5f194189415698233dd1114a093a9b56e61e2c57e11b469be3b0506f46f0771c", size = 2209369, upload-time = "2026-08-28T09:59:53.582Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/5b/844c4defaa34a3df66eb9257087d121d70c201298b96abdf9f492fc2f1bf/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82a36973cf8a2ef5406f4fe2edbf8ed0c99629535d959e0b100c76a32535a111", size = 2253238, upload-time = "2026-08-28T09:59:55.484Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/64/a4e536cb16d7f61a7fd3120b46c577fc7fa7325992f69c4f52bc786d77d8/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdbb78909f52b981d3b2d56b97328d71eb0b974c36bd77c920123a7ebb192829", size = 2065740, upload-time = "2026-08-28T09:59:58.038Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/75/aaa38c6bc2d085f6605b34eabdc6a8a4e0b2e61fc9c8e6e52b28e97b3125/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:52e24eacdb536cade636aa90fb851835222becff8484b7001fdc78cb0290f2aa", size = 2087425, upload-time = "2026-08-28T09:59:59.898Z" },
+    { url = "https://files.pythonhosted.org/packages/55/ae/fcab4cfc39aba3689e1d20c8b5250ad280957022c09af2ed9cd585602a5e/pydantic_core-2.46.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:37ae34309d7bd8c0d61ab839668058f2a7962ea1fc51d105d2db228fe0618034", size = 2139306, upload-time = "2026-08-28T10:00:03.057Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/f4/f1d03a4bc9d9acbc62f4d742b8a319af52f71885079868b2ff8e48a651ee/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:0cdbada856a1c69a7624a64d3d9aefe79300bd6ef827b43a4f265010b9b55184", size = 2144589, upload-time = "2026-08-28T10:00:05.645Z" },
+    { url = "https://files.pythonhosted.org/packages/83/f3/7a53bb1356de514a4cd295f25b6ac39237895620c0462d2592b76c16e114/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:545f26c504b27c3758439a5e6d9349931f0a04f855668d5fe323c89e82300a38", size = 2288882, upload-time = "2026-08-28T10:00:07.931Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/94/5a81583660c175c59d49ffb09f4b3a44debeaf86a19fca664ae1cdd9ee32/pydantic_core-2.46.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:ff218293c9c806138dca139765e3b067621be52bcd93cdc14c7711be7ddc90a9", size = 2335210, upload-time = "2026-08-28T10:00:10.177Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/9f/5d685c2693b972d1a59c998586e8823712b66603aeff47ee60a4bdaafd37/pydantic_core-2.46.5-cp314-cp314t-win32.whl", hash = "sha256:97cf3eb53a8cccacf9d46686a0926186c9bfb5574f2ed66d3639d5fe117cd3a9", size = 1921180, upload-time = "2026-08-28T10:00:12.35Z" },
+    { url = "https://files.pythonhosted.org/packages/70/12/5c94ee16d65a37a15f9e869f5e6256df111154491173801a4c5e800ab548/pydantic_core-2.46.5-cp314-cp314t-win_amd64.whl", hash = "sha256:d2f9fc07a8042a8f95925b35c4f04f469707c981fc33245b6ca187cf5d2dd290", size = 2020515, upload-time = "2026-08-28T10:00:14.774Z" },
+    { url = "https://files.pythonhosted.org/packages/63/19/67830dda664e6bdf9285ee2e40f355d0d7d6b92aa0c42e8d217bb8d33d36/pydantic_core-2.46.5-cp314-cp314t-win_arm64.whl", hash = "sha256:acf8a67ba51f4ca9ddbd0e6b3000a65ac51ab734661778b3e7ba64d99a710f2f", size = 1989276, upload-time = "2026-08-28T10:00:16.984Z" },
 ]
 
 [[package]]

curious_pyapi-0.1.0/src/curious_pyapi/api/curious.py

@@ -1,81 +0,0 @@
-"""Curious API functionality."""
-
-import json
-from typing import Optional
-import httpx
-
-from pydantic import AnyHttpUrl
-
-from ..schema.pyapi import Tokens
-from ..utils.defaults import CURIOUS_BASE_URL, headers
-from ..utils.data import api_data
-from ..utils.logging import get_logger
-
-LOGGER = get_logger(__name__)
-
-
-def get_curious_token(
-    curious_data: dict,
-    curious_headers: Optional[dict] = None,
-    curious_url: httpx.URL | AnyHttpUrl = CURIOUS_BASE_URL,
-) -> Optional[Tokens]:
-    """Process the response to a POST request to the specified URL.
-
-    Parameters
-    ----------
-    curious_data
-        The data to include in the POST request.
-    curious_headers
-        The headers to include in the POST request.
-    curious_url
-        The URL to send the POST request to.
-
-    Returns
-    -------
-    Tokens or None
-        An object containing (access, refresh) token strings, or None if unsuccessful.
-
-    Raises
-    ------
-    RuntimeError
-        If there is an error with the request or response.
-
-    """
-    curious_headers = headers(headers=curious_headers)
-    if isinstance(curious_url, str):
-        curious_url = httpx.URL(curious_url)
-    assert isinstance(curious_url, httpx.URL)
-    try:
-        # Sending the POST request
-        response = httpx.post(
-            curious_url.join("/auth/login"),
-            json=api_data(curious_data),
-            headers=curious_headers,
-        )
-        if response.status_code == httpx.codes.OK:
-            response_data = response.json()  # Convert response to JSON
-            access_token = (
-                response_data.get("result", {})
-                .get("token", {})
-                .get("accessToken", None)
-            )  # Get access token
-            refresh_token = (
-                response_data.get("result", {})
-                .get("token", {})
-                .get("refreshToken", None)
-            )  # Get refresh token
-        else:
-            LOGGER.exception(
-                "Failed to fetch data: %d - %s", response.status_code, response.text
-            )
-            response.raise_for_status()
-            return None
-
-        return Tokens(access=access_token, refresh=refresh_token)
-
-    except httpx.HTTPError as e:
-        msg = f"Error sending request: {e}"
-        raise RuntimeError(msg) from e
-    except json.JSONDecodeError as e:
-        msg = f"Error: Response is not valid JSON! {e}"
-        raise RuntimeError(msg) from e

curious_pyapi-0.1.0/src/curious_pyapi/schema/curious.py

@@ -1,68 +0,0 @@
-"""Curious schemas."""
-
-from typing import Annotated
-
-import polars as pl
-from pydantic.types import StringConstraints
-
-from .regex import EMAIL_REGEX
-from ..utils.logging import get_logger
-
-LOGGER = get_logger(__name__)
-
-
-@pl.api.register_dataframe_namespace("curious_pyapi")
-class CuriousAccount:
-    SCHEMA = pl.Schema(
-        {
-            "email": pl.String,
-            "firstName": pl.String,
-            "lastName": pl.String,
-            "language": pl.String,
-            "secretUserId": pl.String,
-            "nickname": pl.String,
-            "tag": pl.String,
-        }
-    )
-
-    def __init__(self, df: pl.DataFrame):
-        self._df = df
-
-
-def enforce_schema(self) -> pl.DataFrame:
-    """Enforces schema, adds missing columns with nulls, and casts types."""
-    exprs = [
-        pl.col(col).cast(dtype)
-        if col in self._df.columns
-        else pl.lit(None, dtype=dtype).alias(col)
-        for col, dtype in self.SCHEMA.items()
-    ]
-
-    out_df = self._df.select(exprs)
-
-    # Evaluate against out_df where 'email' is guaranteed to exist
-    is_valid_email = pl.col("email").str.contains(EMAIL_REGEX).fill_null(False)
-
-    failures_df = out_df.filter(~is_valid_email)
-    out_df = out_df.filter(is_valid_email)
-
-    if not failures_df.is_empty():
-        log_cols = [
-            col
-            for col in ["email", "secretUserId", "nickname"]
-            if col in failures_df.columns
-        ]
-        LOGGER.error(
-            "Dropped %d records due to invalid email addresses:\n%s",
-            failures_df.height,
-            failures_df.select(log_cols),
-        )
-
-    return out_df
-
-
-CuriousId = Annotated[
-    str,
-    StringConstraints(pattern=r"^[a-zA-Z0-9]{8}(-[a-zA-Z0-9]{4}){3}-[a-zA-Z0-9]{12}$"),
-]
-"""ID string for a Curious entity."""

curious_pyapi-0.1.0/src/curious_pyapi/schema/pyapi.py

@@ -1,29 +0,0 @@
-"""Curious-PyAPI schemas."""
-
-from pydantic import BaseModel, EmailStr, SecretStr
-
-from .curious import CuriousId
-from ..utils.logging import get_logger
-
-logger = get_logger(__name__)
-
-
-class CuriousAuth(BaseModel):
-    """Required data for authentication and decryption."""
-
-    curious_email: EmailStr
-    curious_password: SecretStr
-    applet_id: CuriousId
-    applet_password: SecretStr
-
-    @property
-    def login_credentials(self) -> dict[str, str | SecretStr]:
-        """Return email and password as dictionary for API request."""
-        return {"email": self.curious_email, "password": self.curious_password}
-
-
-class Tokens(BaseModel):
-    """Curious tokens."""
-
-    access: SecretStr
-    refresh: SecretStr