typecast-python 0.3.10__py3-none-any.whl → 0.3.12__py3-none-any.whl

typecast/_httpx_compat.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Tuple
+
+import httpx
+
+
+def _timeout(value: Any) -> Any:
+    if isinstance(value, ClientTimeout):
+        total = value.total or value.sock_read or 5.0
+        return httpx.Timeout(
+            total, connect=value.connect or value.sock_connect or total
+        )
+    if isinstance(value, tuple):
+        return httpx.Timeout(value[1], connect=value[0])
+    return value
+
+
+def _headers(defaults: Dict[str, str], supplied: Optional[dict]) -> Dict[str, str]:
+    headers = dict(defaults)
+    for key, value in (supplied or {}).items():
+        if value is None:
+            headers.pop(key, None)
+        else:
+            headers[key] = value
+    return headers
+
+
+class RequestsCompatResponse:
+    def __init__(self, response: httpx.Response):
+        self._response = response
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._response, name)
+
+    def iter_content(self, chunk_size: int) -> Iterator[bytes]:
+        return self._response.iter_bytes(chunk_size)
+
+    def close(self) -> None:
+        self._response.close()
+
+
+class RequestsCompatSession:
+    def __init__(self, client: Optional[httpx.Client] = None):
+        self._client = client or httpx.Client(timeout=None)
+        self.headers: Dict[str, str] = {}
+
+    def _request(self, method: str, url: str, **kwargs: Any) -> RequestsCompatResponse:
+        stream = kwargs.pop("stream", False)
+        kwargs["headers"] = _headers(self.headers, kwargs.get("headers"))
+        if "timeout" in kwargs:
+            kwargs["timeout"] = _timeout(kwargs["timeout"])
+        if stream:
+            request = self._client.build_request(method, url, **kwargs)
+            response = self._client.send(request, stream=True)
+        else:
+            response = self._client.request(method, url, **kwargs)
+        return RequestsCompatResponse(response)
+
+    def get(self, url: str, **kwargs: Any) -> RequestsCompatResponse:
+        return self._request("GET", url, **kwargs)
+
+    def post(self, url: str, **kwargs: Any) -> RequestsCompatResponse:
+        return self._request("POST", url, **kwargs)
+
+    def delete(self, url: str, **kwargs: Any) -> RequestsCompatResponse:
+        return self._request("DELETE", url, **kwargs)
+
+    def close(self) -> None:
+        self._client.close()
+
+
+class ClientTimeout:
+    def __init__(
+        self,
+        *,
+        total: Optional[float] = None,
+        connect: Optional[float] = None,
+        sock_connect: Optional[float] = None,
+        sock_read: Optional[float] = None,
+    ):
+        self.total = total
+        self.connect = connect
+        self.sock_connect = sock_connect
+        self.sock_read = sock_read
+
+
+class FormData:
+    def __init__(self):
+        self.fields: List[Tuple[str, Any, Optional[str], Optional[str]]] = []
+
+    def add_field(
+        self,
+        name: str,
+        value: Any,
+        *,
+        filename: Optional[str] = None,
+        content_type: Optional[str] = None,
+    ) -> None:
+        self.fields.append((name, value, filename, content_type))
+
+
+class _AsyncContent:
+    def __init__(self, response: httpx.Response):
+        self._response = response
+
+    async def iter_chunked(self, chunk_size: int) -> AsyncIterator[bytes]:
+        async for chunk in self._response.aiter_bytes(chunk_size):
+            yield chunk
+
+
+class AiohttpCompatResponse:
+    def __init__(self, response: httpx.Response):
+        self._response = response
+        self.status = response.status_code
+        self.headers = response.headers
+        self.content = _AsyncContent(response)
+
+    async def read(self) -> bytes:
+        return await self._response.aread()
+
+    async def text(self) -> str:
+        await self._response.aread()
+        return self._response.text
+
+    async def json(self) -> Any:
+        await self._response.aread()
+        return self._response.json()
+
+    async def close(self) -> None:
+        await self._response.aclose()
+
+
+class _AsyncRequestContext:
+    def __init__(self, request: Any):
+        self._request = request
+        self._response: Optional[AiohttpCompatResponse] = None
+
+    async def __aenter__(self) -> AiohttpCompatResponse:
+        response = await self._request
+        self._response = response
+        return response
+
+    async def __aexit__(self, exc_type: Any, exc: Any, tb: Any) -> None:
+        if self._response:
+            await self._response.close()
+
+
+class AiohttpCompatSession:
+    def __init__(
+        self,
+        headers: Optional[dict] = None,
+        client: Optional[httpx.AsyncClient] = None,
+    ):
+        self._client = client or httpx.AsyncClient(timeout=300)
+        self.headers = dict(headers or {})
+
+    async def _request(
+        self, method: str, url: str, **kwargs: Any
+    ) -> AiohttpCompatResponse:
+        kwargs["headers"] = _headers(self.headers, kwargs.get("headers"))
+        if "timeout" in kwargs:
+            kwargs["timeout"] = _timeout(kwargs["timeout"])
+        form = kwargs.get("data")
+        if isinstance(form, FormData):
+            kwargs.pop("data")
+            kwargs["data"] = {
+                name: value
+                for name, value, filename, _ in form.fields
+                if filename is None
+            }
+            kwargs["files"] = [
+                (name, (filename, value, content_type))
+                for name, value, filename, content_type in form.fields
+                if filename is not None
+            ]
+        request = self._client.build_request(method, url, **kwargs)
+        response = await self._client.send(request, stream=True)
+        return AiohttpCompatResponse(response)
+
+    def get(self, url: str, **kwargs: Any) -> _AsyncRequestContext:
+        return _AsyncRequestContext(self._request("GET", url, **kwargs))
+
+    def post(self, url: str, **kwargs: Any) -> _AsyncRequestContext:
+        return _AsyncRequestContext(self._request("POST", url, **kwargs))
+
+    def delete(self, url: str, **kwargs: Any) -> _AsyncRequestContext:
+        return _AsyncRequestContext(self._request("DELETE", url, **kwargs))
+
+    async def close(self) -> None:
+        await self._client.aclose()

typecast/_user_agent.py

@@ -1,13 +1,33 @@
 import platform
+import re
 import sys
 from importlib import metadata
-
-import aiohttp
-import requests
+from typing import Optional
 
 from . import conf
 
 
+_GENERATED_BY_PATTERN = re.compile(r"[a-z0-9][a-z0-9._-]{0,31}\Z")
+
+
+def attribution_suffix(
+    source: Optional[str] = None,
+    generated_by: Optional[str] = None,
+) -> str:
+    if source is None and generated_by is None:
+        return ""
+    if (
+        not isinstance(source, str)
+        or not isinstance(generated_by, str)
+        or source not in {"llms", "skill"}
+        or not generated_by
+    ):
+        raise ValueError("source (llms or skill) and generated_by must be provided together")
+    if not _GENERATED_BY_PATTERN.fullmatch(generated_by):
+        raise ValueError("generated_by must be a lowercase token of at most 32 characters")
+    return f" typecast-integration/1 (source={source}; generated_by={generated_by})"
+
+
 def _package_version(package_name: str) -> str:
     try:
         return metadata.version(package_name)
@@ -39,6 +59,8 @@ def build_user_agent(
     http_library: str,
     host: str,
     transport: str = "rest",
+    source: Optional[str] = None,
+    generated_by: Optional[str] = None,
 ) -> str:
     sdk_version = _package_version("typecast-python")
     base = "default" if conf.is_default_host(host) else "custom"
@@ -49,22 +71,54 @@ def build_user_agent(
         f"{http_library} "
         f"(mode={mode}; base={base}; transport={transport}; "
         f"os={_os_name()}; arch={_arch_name()}; sdk_env=python; platform=server)"
+        f"{attribution_suffix(source, generated_by)}"
     )
 
 
-def requests_user_agent(host: str, transport: str = "rest") -> str:
+def requests_user_agent(
+    host: str,
+    transport: str = "rest",
+    source: Optional[str] = None,
+    generated_by: Optional[str] = None,
+) -> str:
     return build_user_agent(
         mode="sync",
-        http_library=f"requests/{requests.__version__}",
+        http_library=f"requests/{_package_version('requests')}",
         host=host,
         transport=transport,
+        source=source,
+        generated_by=generated_by,
     )
 
 
-def aiohttp_user_agent(host: str, transport: str = "rest") -> str:
+def aiohttp_user_agent(
+    host: str,
+    transport: str = "rest",
+    source: Optional[str] = None,
+    generated_by: Optional[str] = None,
+) -> str:
     return build_user_agent(
         mode="async",
-        http_library=f"aiohttp/{aiohttp.__version__}",
+        http_library=f"aiohttp/{_package_version('aiohttp')}",
+        host=host,
+        transport=transport,
+        source=source,
+        generated_by=generated_by,
+    )
+
+
+def httpx_user_agent(
+    host: str,
+    mode: str,
+    transport: str = "rest",
+    source: Optional[str] = None,
+    generated_by: Optional[str] = None,
+) -> str:
+    return build_user_agent(
+        mode=mode,
+        http_library=f"httpx/{_package_version('httpx')}",
         host=host,
         transport=transport,
+        source=source,
+        generated_by=generated_by,
     )

typecast/async_client.py

@@ -1,11 +1,15 @@
 from __future__ import annotations
 
 import asyncio
+import sys
 from pathlib import Path
-from typing import AsyncIterator, BinaryIO, Optional, Union
+from typing import TYPE_CHECKING, Any, AsyncIterator, BinaryIO, Optional, Union
 from urllib.parse import quote
 
-import aiohttp
+if sys.version_info >= (3, 10):  # pragma: no cover - version-specific import
+    import aiohttp
+else:  # pragma: no cover
+    aiohttp = None  # type: ignore[assignment]
 
 from . import conf
 from ._voice_clone import (
@@ -13,7 +17,10 @@ from ._voice_clone import (
     validate_clone_inputs,
     validate_custom_voice_id,
 )
-from ._user_agent import aiohttp_user_agent
+from ._user_agent import aiohttp_user_agent, attribution_suffix, httpx_user_agent
+
+if TYPE_CHECKING or sys.version_info < (3, 10):  # pragma: no cover
+    from ._httpx_compat import AiohttpCompatSession, ClientTimeout, FormData
 from .client import _guess_audio_mime
 from .client import _output_with_inferred_format
 from .client import _validate_output_path
@@ -69,7 +76,9 @@ class AsyncTypecast:
         self,
         host: Optional[str] = None,
         api_key: Optional[str] = None,
-        session: Optional[aiohttp.ClientSession] = None,
+        session: Optional[Any] = None,
+        source: Optional[str] = None,
+        generated_by: Optional[str] = None,
     ):
         """Initialize the async Typecast client.
 
@@ -81,6 +90,8 @@ class AsyncTypecast:
                 __aenter__ will not create a new session and __aexit__ will not close it
                 (the caller owns its lifecycle). Auth headers (`X-API-KEY`, `User-Agent`)
                 are attached per-request via `_request_headers()`.
+            source: Integration source, either 'llms' or 'skill'.
+            generated_by: Lowercase token identifying the coding agent.
 
         Raises:
             ValueError: If no API key is provided and TYPECAST_API_KEY is not set
@@ -88,19 +99,39 @@ class AsyncTypecast:
         """
         self.host = conf.get_host(host)
         self.api_key = conf.get_api_key(api_key)
+        attribution_suffix(source, generated_by)
+        self.source = source
+        self.generated_by = generated_by
         if not self.api_key and conf.is_default_host(self.host):
             raise ValueError("API key is required for the default Typecast API host")
         self._owns_session = session is None
-        self.session: Optional[aiohttp.ClientSession] = session
+        self.session: Optional[Any] = session
 
     async def __aenter__(self):
         # When an external session is injected, do not create a new one.
         # Per-request auth headers are attached via _request_headers() on each call.
         if self.session is None:
-            headers = {"User-Agent": aiohttp_user_agent(self.host)}
+            headers = {
+                "User-Agent": (
+                    aiohttp_user_agent(
+                        self.host, source=self.source, generated_by=self.generated_by
+                    )
+                    if aiohttp
+                    else httpx_user_agent(
+                        self.host,
+                        "async",
+                        source=self.source,
+                        generated_by=self.generated_by,
+                    )
+                )
+            }
             if self.api_key:
                 headers["X-API-KEY"] = self.api_key
-            self.session = aiohttp.ClientSession(headers=headers)
+            self.session = (
+                aiohttp.ClientSession(headers=headers)
+                if aiohttp
+                else AiohttpCompatSession(headers=headers)
+            )
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
@@ -140,7 +171,11 @@ class AsyncTypecast:
         """
         if self._owns_session:
             return None
-        headers = {"User-Agent": aiohttp_user_agent(self.host)}
+        headers = {
+            "User-Agent": aiohttp_user_agent(
+                self.host, source=self.source, generated_by=self.generated_by
+            )
+        }
         if self.api_key:
             headers["X-API-KEY"] = self.api_key
         return headers
@@ -247,7 +282,11 @@ class AsyncTypecast:
         if not self.session:
             raise TypecastError("Client session not initialized. Use async with.")
         endpoint = "/v1/text-to-speech/stream"
-        stream_timeout = aiohttp.ClientTimeout(sock_connect=10, sock_read=300)
+        stream_timeout = (
+            aiohttp.ClientTimeout(sock_connect=10, sock_read=300)
+            if aiohttp
+            else ClientTimeout(sock_connect=10, sock_read=300)
+        )
         async with self.session.post(
             f"{self.host}{endpoint}",
             json=request.model_dump(exclude_none=True),
@@ -258,7 +297,9 @@ class AsyncTypecast:
                 error_text = await response.text()
                 self._handle_error(response.status, error_text)
 
-            async for chunk in response.content.iter_chunked(chunk_size):  # pragma: no branch
+            async for chunk in response.content.iter_chunked(
+                chunk_size
+            ):  # pragma: no branch
                 yield chunk
 
     async def text_to_speech_with_timestamps(
@@ -332,7 +373,7 @@ class AsyncTypecast:
         audio_bytes, filename = validate_clone_inputs(audio, name)
         model_str = normalize_clone_model(model)
 
-        form = aiohttp.FormData()
+        form: Any = aiohttp.FormData() if aiohttp else FormData()
         form.add_field("name", name)
         form.add_field("model", model_str)
         form.add_field(
@@ -341,7 +382,11 @@ class AsyncTypecast:
             filename=filename,
             content_type=_guess_audio_mime(filename),
         )
-        timeout = aiohttp.ClientTimeout(total=300, connect=10)
+        timeout = (
+            aiohttp.ClientTimeout(total=300, connect=10)
+            if aiohttp
+            else ClientTimeout(total=300, connect=10)
+        )
         async with self.session.post(
             f"{self.host}/v1/voices/clone",
             data=form,
@@ -367,7 +412,11 @@ class AsyncTypecast:
             raise TypecastError("Client session not initialized; use 'async with'.")
 
         validate_custom_voice_id(voice_id)
-        timeout = aiohttp.ClientTimeout(total=60, connect=10)
+        timeout = (
+            aiohttp.ClientTimeout(total=60, connect=10)
+            if aiohttp
+            else ClientTimeout(total=60, connect=10)
+        )
         async with self.session.delete(
             f"{self.host}/v1/voices/{quote(voice_id, safe='')}",
             timeout=timeout,

typecast/client.py

@@ -1,10 +1,14 @@
 from __future__ import annotations
 
+import sys
 from pathlib import Path
-from typing import BinaryIO, Iterator, Optional, Union
+from typing import TYPE_CHECKING, Any, BinaryIO, Iterator, Optional, Union
 from urllib.parse import quote
 
-import requests
+if sys.version_info >= (3, 10):  # pragma: no cover - version-specific import
+    import requests
+else:  # pragma: no cover
+    requests = None  # type: ignore[assignment]
 
 from . import conf
 from ._voice_clone import (
@@ -12,7 +16,10 @@ from ._voice_clone import (
     validate_clone_inputs,
     validate_custom_voice_id,
 )
-from ._user_agent import requests_user_agent
+from ._user_agent import attribution_suffix, httpx_user_agent, requests_user_agent
+
+if TYPE_CHECKING or sys.version_info < (3, 10):  # pragma: no cover
+    from ._httpx_compat import RequestsCompatSession
 from .composer import SpeechComposer
 from .exceptions import (
     BadRequestError,
@@ -103,7 +110,9 @@ class Typecast:
         self,
         host: Optional[str] = None,
         api_key: Optional[str] = None,
-        session: Optional[requests.Session] = None,
+        session: Optional[Any] = None,
+        source: Optional[str] = None,
+        generated_by: Optional[str] = None,
     ):
         """Initialize the Typecast client.
 
@@ -115,22 +124,32 @@ class Typecast:
                 the client will not create a new session nor close it; auth headers
                 (`X-API-KEY`, `User-Agent`) are attached per-request via
                 `_request_headers()`.
+            source: Integration source, either 'llms' or 'skill'.
+            generated_by: Lowercase token identifying the coding agent.
 
         Raises:
             ValueError: If no API key is provided and TYPECAST_API_KEY is not set.
         """
         self.host = conf.get_host(host)
         self.api_key = conf.get_api_key(api_key)
+        attribution_suffix(source, generated_by)
+        self.source = source
+        self.generated_by = generated_by
         if not self.api_key and conf.is_default_host(self.host):
             raise ValueError("API key is required for the default Typecast API host")
         self._owns_session = session is None
+        self.session: Any
         if session is not None:
             self.session = session
         else:
-            self.session = requests.Session()
+            self.session = requests.Session() if requests else RequestsCompatSession()
             headers = {
                 "Content-Type": "application/json",
-                "User-Agent": requests_user_agent(self.host),
+                "User-Agent": (
+                    requests_user_agent(self.host, source=source, generated_by=generated_by)
+                    if requests
+                    else httpx_user_agent(self.host, "sync", source=source, generated_by=generated_by)
+                ),
             }
             if self.api_key:
                 headers["X-API-KEY"] = self.api_key
@@ -167,7 +186,11 @@ class Typecast:
         """
         if self._owns_session:
             return None
-        headers = {"User-Agent": requests_user_agent(self.host)}
+        headers = {
+            "User-Agent": requests_user_agent(
+                self.host, source=self.source, generated_by=self.generated_by
+            )
+        }
         if self.api_key:
             headers["X-API-KEY"] = self.api_key
         return headers

{typecast_python-0.3.10.dist-info → typecast_python-0.3.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: typecast-python
-Version: 0.3.10
+Version: 0.3.12
 Summary: Official Typecast Python SDK - Convert text to lifelike speech using AI-powered voices
 Project-URL: Homepage, https://typecast.ai
 Project-URL: Documentation, https://typecast.ai/docs/overview
@@ -227,20 +227,22 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: <3.15,>=3.8
-Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: aiohttp>=3.14.1; python_version >= '3.10'
+Requires-Dist: httpx<1,>=0.28.1; python_version < '3.10'
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: requests>=2.28.0
+Requires-Dist: requests>=2.33.0; python_version >= '3.10'
 Requires-Dist: typing-extensions>=4.0.0
 Provides-Extra: dev
 Requires-Dist: aioresponses>=0.7.6; extra == 'dev'
-Requires-Dist: black<25.0.0,>=23.0.0; extra == 'dev'
-Requires-Dist: flake8<6.0.0,>=5.0.0; extra == 'dev'
+Requires-Dist: black<27.0.0,>=26.3.1; extra == 'dev'
+Requires-Dist: flake8<8.0.0,>=5.0.0; extra == 'dev'
+Requires-Dist: httpx<1.0.0,>=0.28.1; extra == 'dev'
 Requires-Dist: isort>=5.0.0; extra == 'dev'
-Requires-Dist: mypy<1.11.0,>=1.0.0; extra == 'dev'
-Requires-Dist: pytest-asyncio<1.0.0,>=0.21.0; extra == 'dev'
-Requires-Dist: pytest-cov<6.0.0,>=5.0.0; extra == 'dev'
+Requires-Dist: mypy<2.4.0,>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio<2.0.0,>=1.4.0; extra == 'dev'
+Requires-Dist: pytest-cov<8.0.0,>=5.0.0; extra == 'dev'
 Requires-Dist: pytest-mock>=3.14.0; extra == 'dev'
-Requires-Dist: pytest<9.0.0,>=7.0.0; extra == 'dev'
+Requires-Dist: pytest<10.0.0,>=9.0.3; extra == 'dev'
 Description-Content-Type: text/markdown
 
 <div align="center">

{typecast_python-0.3.10.dist-info → typecast_python-0.3.12.dist-info}/RECORD

@@ -1,8 +1,9 @@
 typecast/__init__.py,sha256=L6m0Z1jn1UgGjPp9AFiTwhHk9DVV_B4WrLfQDEfbcZI,1093
-typecast/_user_agent.py,sha256=R_0eSKpuP9jLp_wDJcJGFvFtUh9BZwEgsT1buVeHRAA,1786
+typecast/_httpx_compat.py,sha256=Xw4AvybiiXyaA2WATBUYHwST8clE8R7R0flLMpdvBC4,6170
+typecast/_user_agent.py,sha256=-QTjpg1fDDsPI_n5sYf-4zPqna_24w0TWqp8OknTthQ,3350
 typecast/_voice_clone.py,sha256=TN2tbB3b5lC5uFCBnbERhz37bNJlbv6VZ-vj70EfTs4,3464
-typecast/async_client.py,sha256=Gidl-gj0zGMzZCPzmMRcr2GiYFi0cBmZOwrLhSVRL_Y,21700
-typecast/client.py,sha256=Ac6hcginhJheh6CcstzaMtyXzRbnSfUerI8rt6l_f58,21695
+typecast/async_client.py,sha256=leZ_DGgeJBDCSr7LJCQ6VxCEt-sjYK8X2khEZIsLO7w,23400
+typecast/client.py,sha256=k-dyxf-JcgXD0WFDW2_K2iRag9iwkTW_wt30z26Qi-0,22756
 typecast/composer.py,sha256=pkRSVIv99uuAwPyOXw7KSW7NAkqvAUK4hCS5pmBb7bA,7313
 typecast/conf.py,sha256=yfOHYZDvIshWWMriN5wE0GFPR8AX3zv4Rg2655OvA9Q,724
 typecast/exceptions.py,sha256=Y0ZzYebe8zOSOSAHbXfKR0G_RJgdmZXxi15Z7ZxPLIk,1568
@@ -12,7 +13,7 @@ typecast/models/error.py,sha256=XomIjx7jvlCjItqzJuCAT4mXC9jwTjxR8lLDUk6P8KA,152
 typecast/models/subscription.py,sha256=EIaAAo3cCRw8LYT_O6D9AVwxqIHrWCijzl4UTx7FZB8,894
 typecast/models/tts.py,sha256=xiO1e936vFr7vZqUErTEhexydoaMem6BcY_x1A1zFow,16495
 typecast/models/voices.py,sha256=3UeBLwAlaNbQQUrt7FO18zqczLoP7jmi2x68yaUtllU,2687
-typecast_python-0.3.10.dist-info/METADATA,sha256=z8W8o3SeRtx4C9PWgEvRCJ3fOcfoVTy2Utp0mqUvkOs,25786
-typecast_python-0.3.10.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-typecast_python-0.3.10.dist-info/licenses/LICENSE,sha256=HvtJ-S89uUkuYmt-OvVk4MRxmzwtbn84__qJtSrGU2Q,11348
-typecast_python-0.3.10.dist-info/RECORD,,
+typecast_python-0.3.12.dist-info/METADATA,sha256=RrOSDitrzeRnGq2syDnkVdWv4H0Cb097jASB02sFIJM,25947
+typecast_python-0.3.12.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+typecast_python-0.3.12.dist-info/licenses/LICENSE,sha256=HvtJ-S89uUkuYmt-OvVk4MRxmzwtbn84__qJtSrGU2Q,11348
+typecast_python-0.3.12.dist-info/RECORD,,

{typecast_python-0.3.10.dist-info → typecast_python-0.3.12.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.31.0
+Generator: hatchling 1.32.0
 Root-Is-Purelib: true
 Tag: py3-none-any