diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 299988b03..403348f77 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -206,7 +206,7 @@ jobs: - name: Upload coverage to Codecov if: always() - uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7 + uses: codecov/codecov-action@0b35c9ecc4f0529d0eb674914510c22f85b196b4 # v7 with: files: coverage-unit.xml flags: unit,py${{ matrix.python-version }} @@ -436,7 +436,7 @@ jobs: - name: Upload coverage to Codecov if: always() && steps.pytest.outcome != 'skipped' - uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7 + uses: codecov/codecov-action@0b35c9ecc4f0529d0eb674914510c22f85b196b4 # v7 with: files: coverage-integration.xml flags: integration,py${{ matrix.python-version }} diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 316f43129..aae42bf29 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -36,7 +36,7 @@ repos: exclude: "test*|tools" args: ["--use-tuple"] - repo: https://github.com/ariebovenberg/slotscheck - rev: v0.21.0b1 + rev: v0.21.0 hooks: - id: slotscheck exclude: "docs|.github" diff --git a/docs/changelog.rst b/docs/changelog.rst index 301faaac2..87c26f338 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -9,6 +9,24 @@ important operational fixes. Recent Updates ============== +v0.63.1 - Slotted service subclass compatibility +------------------------------------------------ + +**Fixed:** + +* Keep :class:`~sqlspec.service.SQLSpecAsyncService` and :class:`~sqlspec.service.SQLSpecSyncService` + as ordinary slotted Python classes in compiled wheels. Application subclasses preserve generic typing + and ``__slots__`` without downstream slotscheck exclusions. Query execution and transaction management + remain mypyc-compiled in a private runtime module. + +**Changed:** + +* Expand compiled-wheel smoke checks to cover multi-level, slotted subclasses of + :class:`~sqlspec.service.SQLSpecAsyncService` and :class:`~sqlspec.service.SQLSpecSyncService`, + including inherited queries, transaction contexts, overridden session acquisition, and queries inside + a caller's exception handler. +* Update slotscheck and the Codecov action pin. + v0.63.0 - Transactions, table fixtures, SQL fragments, storage, and kwargs parameter binding --------------------------------------------------------------------------------------------------- diff --git a/pyproject.toml b/pyproject.toml index d16da3702..7bedc8465 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }] name = "sqlspec" readme = "README.md" requires-python = ">=3.10, <4.0" -version = "0.63.0" +version = "0.63.1" [project.urls] Discord = "https://discord.gg/litestar" @@ -267,7 +267,7 @@ include = [ "sqlspec/storage/backends/local.py", # Local storage backend "sqlspec/storage/backends/obstore.py", # obstore backend import surface "sqlspec/storage/_utils.py", # Storage optional dependency import helpers - "sqlspec/service.py", # Service base classes + "sqlspec/service/_core.py", # Compiled query and transaction helpers for Python service bases "sqlspec/data_dictionary/**/*.py", # Data dictionary registry, loader, and dialect helpers "sqlspec/extensions/prometheus/_observer.py", # Prometheus statement observer "sqlspec/extensions/fastapi/providers.py", # FastAPI filter provider helpers @@ -329,7 +329,7 @@ opt_level = "3" # Maximum optimization (0-3) allow_dirty = true commit = false commit_args = "--no-verify" -current_version = "0.63.0" +current_version = "0.63.1" ignore_missing_files = false ignore_missing_version = false message = "chore(release): bump to v{new_version}" diff --git a/sqlspec/service/__init__.py b/sqlspec/service/__init__.py new file mode 100644 index 000000000..99cd4482c --- /dev/null +++ b/sqlspec/service/__init__.py @@ -0,0 +1,5 @@ +"""Slotted application service bases backed by the compiled service runtime.""" + +from sqlspec.service._base import SQLSpecAsyncService, SQLSpecSyncService + +__all__ = ("SQLSpecAsyncService", "SQLSpecSyncService") diff --git a/sqlspec/service.py b/sqlspec/service/_base.py similarity index 59% rename from sqlspec/service.py rename to sqlspec/service/_base.py index 4bb78d066..cde714fbc 100644 --- a/sqlspec/service.py +++ b/sqlspec/service/_base.py @@ -1,26 +1,29 @@ """Service base classes for SQLSpec application services.""" -import asyncio -import sys -from contextlib import AbstractAsyncContextManager, AbstractContextManager, AsyncExitStack, ExitStack, nullcontext -from contextvars import ContextVar, Token -from threading import get_ident -from typing import TYPE_CHECKING, Any, Generic, Literal, cast, overload - -from mypy_extensions import mypyc_attr +from contextlib import AbstractAsyncContextManager, AbstractContextManager, nullcontext +from typing import TYPE_CHECKING, Any, Generic, cast, overload + from typing_extensions import TypeVar from sqlspec.core import OffsetPagination -from sqlspec.core.filters import LimitOffsetFilter from sqlspec.driver._async import AsyncDriverAdapterBase from sqlspec.driver._sync import SyncDriverAdapterBase -from sqlspec.exceptions import ImproperConfigurationError, NotFoundError +from sqlspec.exceptions import ImproperConfigurationError +from sqlspec.service._core import ( + _async_exists, + _async_get_one, + _async_paginate, + _AsyncBeginTransactionContext, + _sync_exists, + _sync_get_one, + _sync_paginate, + _SyncBeginTransactionContext, + _transaction_session, + _TransactionState, +) from sqlspec.typing import SchemaT -from sqlspec.utils.logging import get_logger if TYPE_CHECKING: - from types import TracebackType - from sqlspec.builder import QueryBuilder from sqlspec.config import AsyncDatabaseConfig, NoPoolAsyncConfig, NoPoolSyncConfig, SyncDatabaseConfig from sqlspec.core.filters import StatementFilter @@ -34,36 +37,7 @@ AsyncDriverT = TypeVar("AsyncDriverT", bound=AsyncDriverAdapterBase, default=AsyncDriverAdapterBase) SyncDriverT = TypeVar("SyncDriverT", bound=SyncDriverAdapterBase, default=SyncDriverAdapterBase) -logger = get_logger("sqlspec.service") - - -def _execution_owner() -> tuple[int, object]: - try: - task = asyncio.current_task() - except RuntimeError: - task = None - return get_ident(), task - - -def _owner_identity(owner: tuple[int, object]) -> tuple[int, int]: - return owner[0], id(owner[1]) - - -class _TransactionState: - __slots__ = ("driver", "origin", "owner") - - def __init__(self, driver: AsyncDriverAdapterBase | SyncDriverAdapterBase) -> None: - self.driver: AsyncDriverAdapterBase | SyncDriverAdapterBase | None = driver - self.owner = _execution_owner() - self.origin = _owner_identity(self.owner) - -_TRANSACTIONS: ContextVar[dict[object, _TransactionState] | None] = ContextVar( - "sqlspec_service_transactions", default=None -) - - -@mypyc_attr(allow_interpreted_subclasses=True) class SQLSpecAsyncService(Generic[AsyncDriverT]): """Base class for asynchronous SQLSpec services. @@ -194,27 +168,9 @@ async def paginate( Returns: An OffsetPagination instance containing items and total count. """ - async with self.provide_session(session) as driver: - limit_offset: LimitOffsetFilter | None = driver.find_filter(LimitOffsetFilter, parameters) - - items, total = await driver.select_with_total( - statement, *parameters, schema_type=schema_type, count_with_window=count_with_window, **kwargs - ) - - if schema_type is None: - return OffsetPagination( - items=cast("list[dict[str, Any]]", items), - limit=limit_offset.limit if limit_offset is not None else len(items), - offset=limit_offset.offset if limit_offset is not None else 0, - total=total, - ) - - return OffsetPagination( - items=cast("list[SchemaT]", items), - limit=limit_offset.limit if limit_offset is not None else len(items), - offset=limit_offset.offset if limit_offset is not None else 0, - total=total, - ) + return await _async_paginate( + self.provide_session(session), statement, parameters, schema_type, count_with_window, kwargs + ) @overload async def get_one( @@ -283,11 +239,9 @@ async def get_one( Raises: NotFoundError: If the query returns zero rows. """ - async with self.provide_session(session) as driver: - result = await driver.select_one_or_none(statement, *parameters, schema_type=schema_type, **kwargs) - if result is None: - raise NotFoundError(error_message or "Record not found") - return result + return await _async_get_one( + self.provide_session(session), statement, parameters, schema_type, error_message, kwargs + ) async def exists( self, @@ -308,8 +262,7 @@ async def exists( Returns: True if at least one row exists, False otherwise. """ - async with self.provide_session(session) as driver: - return await driver.select_one_or_none(statement, *parameters, **kwargs) is not None + return await _async_exists(self.provide_session(session), statement, parameters, kwargs) async def begin(self, *, session: AsyncDriverT | None = None) -> None: """Begin a database transaction on the underlying session. @@ -346,7 +299,6 @@ def begin_transaction(self) -> "_AsyncBeginTransactionContext[AsyncDriverT]": return _AsyncBeginTransactionContext(self) -@mypyc_attr(allow_interpreted_subclasses=True) class SQLSpecSyncService(Generic[SyncDriverT]): """Base class for synchronous SQLSpec services. @@ -477,27 +429,9 @@ def paginate( Returns: An OffsetPagination instance containing items and total count. """ - with self.provide_session(session) as driver: - limit_offset: LimitOffsetFilter | None = driver.find_filter(LimitOffsetFilter, parameters) - - items, total = driver.select_with_total( - statement, *parameters, schema_type=schema_type, count_with_window=count_with_window, **kwargs - ) - - if schema_type is None: - return OffsetPagination( - items=cast("list[dict[str, Any]]", items), - limit=limit_offset.limit if limit_offset is not None else len(items), - offset=limit_offset.offset if limit_offset is not None else 0, - total=total, - ) - - return OffsetPagination( - items=cast("list[SchemaT]", items), - limit=limit_offset.limit if limit_offset is not None else len(items), - offset=limit_offset.offset if limit_offset is not None else 0, - total=total, - ) + return _sync_paginate( + self.provide_session(session), statement, parameters, schema_type, count_with_window, kwargs + ) @overload def get_one( @@ -566,11 +500,7 @@ def get_one( Raises: NotFoundError: If the query returns zero rows. """ - with self.provide_session(session) as driver: - result = driver.select_one_or_none(statement, *parameters, schema_type=schema_type, **kwargs) - if result is None: - raise NotFoundError(error_message or "Record not found") - return result + return _sync_get_one(self.provide_session(session), statement, parameters, schema_type, error_message, kwargs) def exists( self, @@ -591,8 +521,7 @@ def exists( Returns: True if at least one row exists, False otherwise. """ - with self.provide_session(session) as driver: - return driver.select_one_or_none(statement, *parameters, **kwargs) is not None + return _sync_exists(self.provide_session(session), statement, parameters, kwargs) def begin(self, *, session: SyncDriverT | None = None) -> None: """Begin a database transaction on the underlying session. @@ -627,251 +556,3 @@ def begin_transaction(self) -> "_SyncBeginTransactionContext[SyncDriverT]": The underlying driver session bound to the active transaction. """ return _SyncBeginTransactionContext(self) - - -def _active_transaction(key: object) -> _TransactionState | None: - state = (_TRANSACTIONS.get() or {}).get(key) - if state is None: - return None - if state.driver is None: - if state.origin == _owner_identity(_execution_owner()): - _discard_transaction(state) - return None - msg = "The inherited service transaction is no longer active." - raise ImproperConfigurationError(msg) - if state.owner != _execution_owner(): - msg = "A service transaction cannot be implicitly reused by another task or thread; pass session= explicitly." - raise ImproperConfigurationError(msg) - return state - - -def _live_transaction(key: object) -> _TransactionState | None: - current = _TRANSACTIONS.get() - state = None if current is None else current.get(key) - if state is None: - return None - if state.driver is None: - _discard_transaction(state) - return None - return _active_transaction(key) - - -def _discard_transaction(state: _TransactionState) -> None: - current = _TRANSACTIONS.get() - if current is not None and any(value is state for value in current.values()): - _TRANSACTIONS.set({key: value for key, value in current.items() if value is not state} or None) - - -def _session_transaction(state: _TransactionState | None) -> _TransactionState | None: - if state is None or state.driver is None: - return None - if state.owner != _execution_owner(): - msg = ( - "A service transaction is active in another task or thread; nested begin_transaction() blocks must " - "run in the task or thread that entered the outer block." - ) - raise ImproperConfigurationError(msg) - return state - - -def _connection_in_transaction(driver: AsyncDriverAdapterBase | SyncDriverAdapterBase) -> bool: - try: - return driver._connection_in_transaction() - except NotImplementedError: - return False - - -def _transaction_session(key: object) -> AsyncDriverAdapterBase | SyncDriverAdapterBase | None: - state = _active_transaction(key) - return None if state is None else state.driver - - -def _bind_transaction( - key: object, driver: AsyncDriverAdapterBase | SyncDriverAdapterBase -) -> tuple[_TransactionState, Token[dict[object, _TransactionState] | None]]: - state = _TransactionState(driver) - token = _TRANSACTIONS.set({**(_TRANSACTIONS.get() or {}), key: state}) - return state, token - - -def _release_transaction(state: _TransactionState, token: Token[dict[object, _TransactionState] | None]) -> None: - state.driver = None - state.owner = (0, None) - try: - _TRANSACTIONS.reset(token) - except ValueError: - _discard_transaction(state) - - -class _AsyncBeginTransactionContext(Generic[AsyncDriverT]): - __slots__ = ("_nested", "_service", "_stack", "_state") - - def __init__(self, service: "SQLSpecAsyncService[AsyncDriverT]") -> None: - self._service = service - self._stack: AsyncExitStack | None = None - self._state: _TransactionState | None = None - self._nested: Any = None - - async def __aenter__(self) -> AsyncDriverT: - service = self._service - if service._config is None: - active = _session_transaction(service._transaction_state) - session = service.session - if active is not None or session._transaction_depth > 0: - nested = session.transaction() - await nested.__aenter__() - self._nested = nested - return session - if not _connection_in_transaction(session): - await service.begin() - session._transaction_depth += 1 - state = _TransactionState(session) - service._transaction_state = state - self._state = state - return session - key = service._transaction_key - live = _live_transaction(key) - if live is not None: - driver = cast("AsyncDriverT", live.driver) - nested = driver.transaction() - await nested.__aenter__() - self._nested = nested - return driver - stack = AsyncExitStack() - try: - driver = await stack.enter_async_context(service.provide_session()) - await stack.enter_async_context(driver.transaction()) - state, token = _bind_transaction(key, driver) - stack.callback(_release_transaction, state, token) - except BaseException: - await stack.__aexit__(*sys.exc_info()) - raise - self._stack = stack - self._state = state - return driver - - async def __aexit__( - self, exc_type: "type[BaseException] | None", exc: "BaseException | None", traceback: "TracebackType | None" - ) -> "Literal[False]": - service = self._service - nested = self._nested - state = self._state - stack = self._stack - self._nested = None - self._state = None - self._stack = None - if nested is not None: - await nested.__aexit__(exc_type, exc, traceback) - return False - if stack is not None: - await stack.__aexit__(exc_type, exc, traceback) - return False - if state is None: - return False - session = cast("AsyncDriverAdapterBase", state.driver) - try: - if exc_type is not None: - await service.rollback() - return False - try: - await service.commit() - except BaseException: - try: - await service.rollback() - except Exception: - logger.debug("Rollback after a failed commit also failed", exc_info=True) - raise - return False - finally: - if session._transaction_depth > 0: - session._transaction_depth -= 1 - state.driver = None - if service._transaction_state is state: - service._transaction_state = None - - -class _SyncBeginTransactionContext(Generic[SyncDriverT]): - __slots__ = ("_nested", "_service", "_stack", "_state") - - def __init__(self, service: "SQLSpecSyncService[SyncDriverT]") -> None: - self._service = service - self._stack: ExitStack | None = None - self._state: _TransactionState | None = None - self._nested: Any = None - - def __enter__(self) -> SyncDriverT: - service = self._service - if service._config is None: - active = _session_transaction(service._transaction_state) - session = service.session - if active is not None or session._transaction_depth > 0: - nested = session.transaction() - nested.__enter__() - self._nested = nested - return session - if not _connection_in_transaction(session): - service.begin() - session._transaction_depth += 1 - state = _TransactionState(session) - service._transaction_state = state - self._state = state - return session - key = service._transaction_key - live = _live_transaction(key) - if live is not None: - driver = cast("SyncDriverT", live.driver) - nested = driver.transaction() - nested.__enter__() - self._nested = nested - return driver - stack = ExitStack() - try: - driver = stack.enter_context(service.provide_session()) - stack.enter_context(driver.transaction()) - state, token = _bind_transaction(key, driver) - stack.callback(_release_transaction, state, token) - except BaseException: - stack.__exit__(*sys.exc_info()) - raise - self._stack = stack - self._state = state - return driver - - def __exit__( - self, exc_type: "type[BaseException] | None", exc: "BaseException | None", traceback: "TracebackType | None" - ) -> "Literal[False]": - service = self._service - nested = self._nested - state = self._state - stack = self._stack - self._nested = None - self._state = None - self._stack = None - if nested is not None: - nested.__exit__(exc_type, exc, traceback) - return False - if stack is not None: - stack.__exit__(exc_type, exc, traceback) - return False - if state is None: - return False - session = cast("SyncDriverAdapterBase", state.driver) - try: - if exc_type is not None: - service.rollback() - return False - try: - service.commit() - except BaseException: - try: - service.rollback() - except Exception: - logger.debug("Rollback after a failed commit also failed", exc_info=True) - raise - return False - finally: - if session._transaction_depth > 0: - session._transaction_depth -= 1 - state.driver = None - if service._transaction_state is state: - service._transaction_state = None diff --git a/sqlspec/service/_core.py b/sqlspec/service/_core.py new file mode 100644 index 000000000..f200e8ab1 --- /dev/null +++ b/sqlspec/service/_core.py @@ -0,0 +1,423 @@ +"""Compiled query and transaction runtime for the Python service bases.""" + +import asyncio +import sys +from contextlib import AbstractAsyncContextManager, AbstractContextManager, AsyncExitStack, ExitStack +from contextvars import ContextVar, Token +from threading import get_ident +from typing import TYPE_CHECKING, Any, Generic, Literal, cast + +from typing_extensions import TypeVar + +from sqlspec.core import OffsetPagination +from sqlspec.core.filters import LimitOffsetFilter +from sqlspec.driver._async import AsyncDriverAdapterBase +from sqlspec.driver._sync import SyncDriverAdapterBase +from sqlspec.exceptions import ImproperConfigurationError, NotFoundError +from sqlspec.utils.logging import get_logger + +if TYPE_CHECKING: + from types import TracebackType + + from sqlspec.builder import QueryBuilder + from sqlspec.core.filters import StatementFilter + from sqlspec.core.statement import Statement + from sqlspec.service import SQLSpecAsyncService, SQLSpecSyncService + from sqlspec.typing import SchemaT, StatementParameters + +AsyncDriverT = TypeVar("AsyncDriverT", bound=AsyncDriverAdapterBase, default=AsyncDriverAdapterBase) +SyncDriverT = TypeVar("SyncDriverT", bound=SyncDriverAdapterBase, default=SyncDriverAdapterBase) + +logger = get_logger("sqlspec.service") + + +def _execution_owner() -> tuple[int, object]: + try: + task = asyncio.current_task() + except RuntimeError: + task = None + return get_ident(), task + + +def _owner_identity(owner: tuple[int, object]) -> tuple[int, int]: + return owner[0], id(owner[1]) + + +class _TransactionState: + __slots__ = ("driver", "origin", "owner") + + def __init__(self, driver: AsyncDriverAdapterBase | SyncDriverAdapterBase) -> None: + self.driver: AsyncDriverAdapterBase | SyncDriverAdapterBase | None = driver + self.owner = _execution_owner() + self.origin = _owner_identity(self.owner) + + +_TRANSACTIONS: ContextVar[dict[object, _TransactionState] | None] = ContextVar( + "sqlspec_service_transactions", default=None +) + + +async def _async_paginate( + context: AbstractAsyncContextManager[AsyncDriverAdapterBase], + statement: "Statement | QueryBuilder", + parameters: "tuple[StatementParameters | StatementFilter, ...]", + schema_type: "type[SchemaT] | None", + count_with_window: bool, + kwargs: dict[str, Any], +) -> "OffsetPagination[SchemaT] | OffsetPagination[dict[str, Any]]": + """Execute the async service paginate operation in the supplied session context.""" + async with context as driver: + limit_offset: LimitOffsetFilter | None = driver.find_filter(LimitOffsetFilter, parameters) + + items, total = await driver.select_with_total( + statement, *parameters, schema_type=schema_type, count_with_window=count_with_window, **kwargs + ) + + if schema_type is None: + return OffsetPagination( + items=cast("list[dict[str, Any]]", items), + limit=limit_offset.limit if limit_offset is not None else len(items), + offset=limit_offset.offset if limit_offset is not None else 0, + total=total, + ) + + return OffsetPagination( + items=cast("list[SchemaT]", items), + limit=limit_offset.limit if limit_offset is not None else len(items), + offset=limit_offset.offset if limit_offset is not None else 0, + total=total, + ) + + +async def _async_get_one( + context: AbstractAsyncContextManager[AsyncDriverAdapterBase], + statement: "Statement | QueryBuilder", + parameters: "tuple[StatementParameters | StatementFilter, ...]", + schema_type: "type[SchemaT] | None", + error_message: str | None, + kwargs: dict[str, Any], +) -> "SchemaT | dict[str, Any]": + """Execute the async service get_one operation in the supplied session context.""" + async with context as driver: + result = await driver.select_one_or_none(statement, *parameters, schema_type=schema_type, **kwargs) + if result is None: + raise NotFoundError(error_message or "Record not found") + return result + + +async def _async_exists( + context: AbstractAsyncContextManager[AsyncDriverAdapterBase], + statement: "Statement | QueryBuilder", + parameters: "tuple[StatementParameters | StatementFilter, ...]", + kwargs: dict[str, Any], +) -> bool: + """Execute the async service exists operation in the supplied session context.""" + async with context as driver: + return await driver.select_one_or_none(statement, *parameters, **kwargs) is not None + + +def _sync_paginate( + context: AbstractContextManager[SyncDriverAdapterBase], + statement: "Statement | QueryBuilder", + parameters: "tuple[StatementParameters | StatementFilter, ...]", + schema_type: "type[SchemaT] | None", + count_with_window: bool, + kwargs: dict[str, Any], +) -> "OffsetPagination[SchemaT] | OffsetPagination[dict[str, Any]]": + """Execute the sync service paginate operation in the supplied session context.""" + with context as driver: + limit_offset: LimitOffsetFilter | None = driver.find_filter(LimitOffsetFilter, parameters) + + items, total = driver.select_with_total( + statement, *parameters, schema_type=schema_type, count_with_window=count_with_window, **kwargs + ) + + if schema_type is None: + return OffsetPagination( + items=cast("list[dict[str, Any]]", items), + limit=limit_offset.limit if limit_offset is not None else len(items), + offset=limit_offset.offset if limit_offset is not None else 0, + total=total, + ) + + return OffsetPagination( + items=cast("list[SchemaT]", items), + limit=limit_offset.limit if limit_offset is not None else len(items), + offset=limit_offset.offset if limit_offset is not None else 0, + total=total, + ) + + +def _sync_get_one( + context: AbstractContextManager[SyncDriverAdapterBase], + statement: "Statement | QueryBuilder", + parameters: "tuple[StatementParameters | StatementFilter, ...]", + schema_type: "type[SchemaT] | None", + error_message: str | None, + kwargs: dict[str, Any], +) -> "SchemaT | dict[str, Any]": + """Execute the sync service get_one operation in the supplied session context.""" + with context as driver: + result = driver.select_one_or_none(statement, *parameters, schema_type=schema_type, **kwargs) + if result is None: + raise NotFoundError(error_message or "Record not found") + return result + + +def _sync_exists( + context: AbstractContextManager[SyncDriverAdapterBase], + statement: "Statement | QueryBuilder", + parameters: "tuple[StatementParameters | StatementFilter, ...]", + kwargs: dict[str, Any], +) -> bool: + """Execute the sync service exists operation in the supplied session context.""" + with context as driver: + return driver.select_one_or_none(statement, *parameters, **kwargs) is not None + + +def _active_transaction(key: object) -> _TransactionState | None: + state = (_TRANSACTIONS.get() or {}).get(key) + if state is None: + return None + if state.driver is None: + if state.origin == _owner_identity(_execution_owner()): + _discard_transaction(state) + return None + msg = "The inherited service transaction is no longer active." + raise ImproperConfigurationError(msg) + if state.owner != _execution_owner(): + msg = "A service transaction cannot be implicitly reused by another task or thread; pass session= explicitly." + raise ImproperConfigurationError(msg) + return state + + +def _live_transaction(key: object) -> _TransactionState | None: + current = _TRANSACTIONS.get() + state = None if current is None else current.get(key) + if state is None: + return None + if state.driver is None: + _discard_transaction(state) + return None + return _active_transaction(key) + + +def _discard_transaction(state: _TransactionState) -> None: + current = _TRANSACTIONS.get() + if current is not None and any(value is state for value in current.values()): + _TRANSACTIONS.set({key: value for key, value in current.items() if value is not state} or None) + + +def _session_transaction(state: _TransactionState | None) -> _TransactionState | None: + if state is None or state.driver is None: + return None + if state.owner != _execution_owner(): + msg = ( + "A service transaction is active in another task or thread; nested begin_transaction() blocks must " + "run in the task or thread that entered the outer block." + ) + raise ImproperConfigurationError(msg) + return state + + +def _connection_in_transaction(driver: AsyncDriverAdapterBase | SyncDriverAdapterBase) -> bool: + try: + return driver._connection_in_transaction() + except NotImplementedError: + return False + + +def _transaction_session(key: object) -> AsyncDriverAdapterBase | SyncDriverAdapterBase | None: + state = _active_transaction(key) + return None if state is None else state.driver + + +def _bind_transaction( + key: object, driver: AsyncDriverAdapterBase | SyncDriverAdapterBase +) -> tuple[_TransactionState, Token[dict[object, _TransactionState] | None]]: + state = _TransactionState(driver) + token = _TRANSACTIONS.set({**(_TRANSACTIONS.get() or {}), key: state}) + return state, token + + +def _release_transaction(state: _TransactionState, token: Token[dict[object, _TransactionState] | None]) -> None: + state.driver = None + state.owner = (0, None) + try: + _TRANSACTIONS.reset(token) + except ValueError: + _discard_transaction(state) + + +class _AsyncBeginTransactionContext(Generic[AsyncDriverT]): + __slots__ = ("_nested", "_service", "_stack", "_state") + + def __init__(self, service: "SQLSpecAsyncService[AsyncDriverT]") -> None: + self._service = service + self._stack: AsyncExitStack | None = None + self._state: _TransactionState | None = None + self._nested: Any = None + + async def __aenter__(self) -> AsyncDriverT: + service = self._service + if service._config is None: + active = _session_transaction(service._transaction_state) + session = service.session + if active is not None or session._transaction_depth > 0: + nested = session.transaction() + await nested.__aenter__() + self._nested = nested + return session + if not _connection_in_transaction(session): + await service.begin() + session._transaction_depth += 1 + state = _TransactionState(session) + service._transaction_state = state + self._state = state + return session + key = service._transaction_key + live = _live_transaction(key) + if live is not None: + driver = cast("AsyncDriverT", live.driver) + nested = driver.transaction() + await nested.__aenter__() + self._nested = nested + return driver + stack = AsyncExitStack() + try: + driver = await stack.enter_async_context(service.provide_session()) + await stack.enter_async_context(driver.transaction()) + state, token = _bind_transaction(key, driver) + stack.callback(_release_transaction, state, token) + except BaseException: + await stack.__aexit__(*sys.exc_info()) + raise + self._stack = stack + self._state = state + return driver + + async def __aexit__( + self, exc_type: "type[BaseException] | None", exc: "BaseException | None", traceback: "TracebackType | None" + ) -> "Literal[False]": + service = self._service + nested = self._nested + state = self._state + stack = self._stack + self._nested = None + self._state = None + self._stack = None + if nested is not None: + await nested.__aexit__(exc_type, exc, traceback) + return False + if stack is not None: + await stack.__aexit__(exc_type, exc, traceback) + return False + if state is None: + return False + session = cast("AsyncDriverAdapterBase", state.driver) + try: + if exc_type is not None: + await service.rollback() + return False + try: + await service.commit() + except BaseException: + try: + await service.rollback() + except Exception: + logger.debug("Rollback after a failed commit also failed", exc_info=True) + raise + return False + finally: + if session._transaction_depth > 0: + session._transaction_depth -= 1 + state.driver = None + if service._transaction_state is state: + service._transaction_state = None + + +class _SyncBeginTransactionContext(Generic[SyncDriverT]): + __slots__ = ("_nested", "_service", "_stack", "_state") + + def __init__(self, service: "SQLSpecSyncService[SyncDriverT]") -> None: + self._service = service + self._stack: ExitStack | None = None + self._state: _TransactionState | None = None + self._nested: Any = None + + def __enter__(self) -> SyncDriverT: + service = self._service + if service._config is None: + active = _session_transaction(service._transaction_state) + session = service.session + if active is not None or session._transaction_depth > 0: + nested = session.transaction() + nested.__enter__() + self._nested = nested + return session + if not _connection_in_transaction(session): + service.begin() + session._transaction_depth += 1 + state = _TransactionState(session) + service._transaction_state = state + self._state = state + return session + key = service._transaction_key + live = _live_transaction(key) + if live is not None: + driver = cast("SyncDriverT", live.driver) + nested = driver.transaction() + nested.__enter__() + self._nested = nested + return driver + stack = ExitStack() + try: + driver = stack.enter_context(service.provide_session()) + stack.enter_context(driver.transaction()) + state, token = _bind_transaction(key, driver) + stack.callback(_release_transaction, state, token) + except BaseException: + stack.__exit__(*sys.exc_info()) + raise + self._stack = stack + self._state = state + return driver + + def __exit__( + self, exc_type: "type[BaseException] | None", exc: "BaseException | None", traceback: "TracebackType | None" + ) -> "Literal[False]": + service = self._service + nested = self._nested + state = self._state + stack = self._stack + self._nested = None + self._state = None + self._stack = None + if nested is not None: + nested.__exit__(exc_type, exc, traceback) + return False + if stack is not None: + stack.__exit__(exc_type, exc, traceback) + return False + if state is None: + return False + session = cast("SyncDriverAdapterBase", state.driver) + try: + if exc_type is not None: + service.rollback() + return False + try: + service.commit() + except BaseException: + try: + service.rollback() + except Exception: + logger.debug("Rollback after a failed commit also failed", exc_info=True) + raise + return False + finally: + if session._transaction_depth > 0: + session._transaction_depth -= 1 + state.driver = None + if service._transaction_state is state: + service._transaction_state = None diff --git a/tests/unit/test_service.py b/tests/unit/test_service.py index f1f4a249f..7a2a5767c 100644 --- a/tests/unit/test_service.py +++ b/tests/unit/test_service.py @@ -1,74 +1,67 @@ -"""Transaction-context semantics for the SQLSpec service base classes. - -These tests lock in the commit-on-success / rollback-on-error behavior of -``begin_transaction`` for both the sync and async service bases, and assert that -neither context manager suppresses exceptions raised inside the ``with`` body. -The non-suppression guarantee is what lets callers ``return`` from inside the -block without a trailing unreachable ``raise`` to satisfy type checkers. -""" +"""Service transaction hooks commit on success and roll back without suppressing errors.""" from unittest.mock import AsyncMock, MagicMock import pytest +from sqlspec.adapters.aiosqlite import AiosqliteConfig, AiosqliteDriver +from sqlspec.adapters.sqlite import SqliteConfig, SqliteDriver from sqlspec.service import SQLSpecAsyncService, SQLSpecSyncService pytestmark = pytest.mark.anyio -async def test_async_begin_transaction_commits_on_success() -> None: - session = AsyncMock() - session._transaction_depth = 0 - session._connection_in_transaction = MagicMock(return_value=False) - service: SQLSpecAsyncService = SQLSpecAsyncService(session) - - async with service.begin_transaction() as bound: - assert bound is session - - session.begin.assert_awaited_once() - session.commit.assert_awaited_once() - session.rollback.assert_not_awaited() - - -async def test_async_begin_transaction_rolls_back_and_propagates() -> None: - session = AsyncMock() - session._transaction_depth = 0 - session._connection_in_transaction = MagicMock(return_value=False) - service: SQLSpecAsyncService = SQLSpecAsyncService(session) - - with pytest.raises(ValueError, match="boom"): - async with service.begin_transaction(): - raise ValueError("boom") - - session.begin.assert_awaited_once() - session.rollback.assert_awaited_once() - session.commit.assert_not_awaited() - - -def test_sync_begin_transaction_commits_on_success() -> None: - session = MagicMock() - session._transaction_depth = 0 - session._connection_in_transaction.return_value = False - service: SQLSpecSyncService = SQLSpecSyncService(session) - - with service.begin_transaction() as bound: - assert bound is session - - session.begin.assert_called_once() - session.commit.assert_called_once() - session.rollback.assert_not_called() - - -def test_sync_begin_transaction_rolls_back_and_propagates() -> None: - session = MagicMock() - session._transaction_depth = 0 - session._connection_in_transaction.return_value = False - service: SQLSpecSyncService = SQLSpecSyncService(session) - - with pytest.raises(ValueError, match="boom"): - with service.begin_transaction(): - raise ValueError("boom") - - session.begin.assert_called_once() - session.rollback.assert_called_once() - session.commit.assert_not_called() +@pytest.mark.parametrize("fail", [False, True]) +async def test_async_begin_transaction_hooks(monkeypatch: pytest.MonkeyPatch, fail: bool) -> None: + begin, commit, rollback = AsyncMock(), AsyncMock(), AsyncMock() + monkeypatch.setattr(AiosqliteDriver, "begin", begin) + monkeypatch.setattr(AiosqliteDriver, "commit", commit) + monkeypatch.setattr(AiosqliteDriver, "rollback", rollback) + config = AiosqliteConfig() + try: + async with config.provide_session() as session: + service = SQLSpecAsyncService(session) + if fail: + with pytest.raises(ValueError, match="boom"): + async with service.begin_transaction() as bound: + assert bound is session + raise ValueError("boom") + rollback.assert_awaited_once() + commit.assert_not_awaited() + else: + async with service.begin_transaction() as bound: + assert bound is session + commit.assert_awaited_once() + rollback.assert_not_awaited() + begin.assert_awaited_once() + assert session._transaction_depth == 0 + finally: + await config.close_pool() + + +@pytest.mark.parametrize("fail", [False, True]) +def test_sync_begin_transaction_hooks(monkeypatch: pytest.MonkeyPatch, fail: bool) -> None: + begin, commit, rollback = MagicMock(), MagicMock(), MagicMock() + monkeypatch.setattr(SqliteDriver, "begin", begin) + monkeypatch.setattr(SqliteDriver, "commit", commit) + monkeypatch.setattr(SqliteDriver, "rollback", rollback) + config = SqliteConfig() + try: + with config.provide_session() as session: + service = SQLSpecSyncService(session) + if fail: + with pytest.raises(ValueError, match="boom"): + with service.begin_transaction() as bound: + assert bound is session + raise ValueError("boom") + rollback.assert_called_once() + commit.assert_not_called() + else: + with service.begin_transaction() as bound: + assert bound is session + commit.assert_called_once() + rollback.assert_not_called() + begin.assert_called_once() + assert session._transaction_depth == 0 + finally: + config.close_pool() diff --git a/tests/unit/test_service_config.py b/tests/unit/test_service_config.py index 0fe962a93..5058e2671 100644 --- a/tests/unit/test_service_config.py +++ b/tests/unit/test_service_config.py @@ -20,7 +20,8 @@ from sqlspec.adapters.sqlite import SqliteConfig, SqliteDriver from sqlspec.exceptions import ImproperConfigurationError, NotFoundError, SQLSpecError from sqlspec.loader import SQLFileLoader -from sqlspec.service import _TRANSACTIONS, SQLSpecAsyncService, SQLSpecSyncService +from sqlspec.service import SQLSpecAsyncService, SQLSpecSyncService +from sqlspec.service._core import _TRANSACTIONS pytestmark = pytest.mark.anyio diff --git a/tools/scripts/mypyc_inventory.py b/tools/scripts/mypyc_inventory.py index 5049c93f8..5acfc774e 100644 --- a/tools/scripts/mypyc_inventory.py +++ b/tools/scripts/mypyc_inventory.py @@ -29,6 +29,14 @@ SURFACE_ORDER = ("compiled", "candidate", "hard_block", "keep_interpreted", "interpreted") HOT_SURFACE_CLASSIFICATIONS: dict[str, dict[str, str]] = { + "sqlspec/service/_base.py": { + "classification": "keep_interpreted", + "reason": "Public generic service bases preserve Python slots and subclassing; runtime helpers compile separately.", + }, + "sqlspec/service/_core.py": { + "classification": "compile_now", + "reason": "Query execution and transaction ownership runtime behind the Python service bases.", + }, "sqlspec/config.py": { "classification": "helper_split_first", "reason": "Owns runtime hooks, migration setup, and observability/bootstrap orchestration.", diff --git a/tools/scripts/mypyc_smoke.py b/tools/scripts/mypyc_smoke.py index d3b226885..5ba768a67 100644 --- a/tools/scripts/mypyc_smoke.py +++ b/tools/scripts/mypyc_smoke.py @@ -633,6 +633,144 @@ def _check_adapter_config_construction() -> dict[str, Any]: return result +def _check_service_subclasses(*, require_compiled: bool = False) -> dict[str, Any]: + """Exercise Python service subclasses against the compiled query and transaction runtime.""" + result = _new_smoke_result( + name="service_subclasses", module="sqlspec.service._core", attribute=None, compiled_required=require_compiled + ) + try: + service_module = importlib.import_module("sqlspec.service._core") + importlib.import_module("aiosqlite") + except ModuleNotFoundError as exc: + if _is_missing_optional_dependency(exc.name or "", "aiosqlite"): + result["skipped"] = True + result["skip_reason"] = "optional dependency missing: aiosqlite" + return result + result["error"] = f"{type(exc).__name__}: {exc}" + return result + except Exception as exc: + result["error"] = f"{type(exc).__name__}: {exc}" + return result + + result["imported"] = True + result["compiled"] = is_compiled_module(service_module) + if require_compiled and not result["compiled"]: + result["error"] = "module was imported from Python source, not a compiled extension" + return result + + child_script = """ +import asyncio +import sys + +from sqlspec.adapters.aiosqlite import AiosqliteConfig, AiosqliteDriver +from sqlspec.adapters.sqlite import SqliteConfig, SqliteDriver +from sqlspec.service import SQLSpecAsyncService, SQLSpecSyncService + +if sys.argv[1] == "compiled": + from importlib.machinery import EXTENSION_SUFFIXES + import sqlspec.service._core + + assert sqlspec.service._core.__file__.endswith(tuple(EXTENSION_SUFFIXES)) + + +class AppSyncService(SQLSpecSyncService[SqliteDriver]): + __slots__ = ("calls",) + + def __init__(self, config): + super().__init__(config=config) + self.calls = 0 + + def provide_session(self, session=None): + self.calls += 1 + return super().provide_session(session) + + +class SyncService(AppSyncService): + __slots__ = () + + +class AppAsyncService(SQLSpecAsyncService[AiosqliteDriver]): + __slots__ = ("calls",) + + def __init__(self, config): + super().__init__(config=config) + self.calls = 0 + + def provide_session(self, session=None): + self.calls += 1 + return super().provide_session(session) + + +class AsyncService(AppAsyncService): + __slots__ = () + + +for base in (SQLSpecAsyncService, SQLSpecSyncService, SyncService, AsyncService): + assert base.__dictoffset__ == 0, base + assert "__slots__" in vars(base), base + + +config = SqliteConfig() +try: + service = SyncService(config) + assert service.get_one("SELECT 1 AS value") == {"value": 1} + assert service.calls == 1 + with service.begin_transaction() as session: + assert service.session is session + assert service.get_one("SELECT 2 AS value") == {"value": 2} + assert service.calls == 3 + try: + raise ValueError("caller error") + except ValueError: + assert service.exists("SELECT 1") + assert service.paginate("SELECT value FROM (SELECT 1 AS value) AS source").items == [{"value": 1}] + assert service.get_one("SELECT 1 AS value") == {"value": 1} +finally: + config.close_pool() + + +async def main(): + config = AiosqliteConfig() + try: + service = AsyncService(config) + assert await service.get_one("SELECT 1 AS value") == {"value": 1} + assert service.calls == 1 + async with service.begin_transaction() as session: + assert service.session is session + assert await service.get_one("SELECT 2 AS value") == {"value": 2} + assert service.calls == 3 + try: + raise ValueError("caller error") + except ValueError: + assert await service.exists("SELECT 1") + assert (await service.paginate("SELECT value FROM (SELECT 1 AS value) AS source")).items == [{"value": 1}] + assert await service.get_one("SELECT 1 AS value") == {"value": 1} + finally: + await config.close_pool() + + +asyncio.run(main()) +print("service-subclasses:ok") +""" + try: + completed = subprocess.run( + [sys.executable, "-I", "-c", child_script, "compiled" if require_compiled else "source"], + capture_output=True, + check=False, + text=True, + timeout=30, + ) + except subprocess.TimeoutExpired: + result["error"] = "service subclass subprocess timed out" + return result + if completed.returncode != 0 or "service-subclasses:ok" not in completed.stdout: + result["error"] = ( + f"service subclass subprocess failed with return code {completed.returncode}; " + f"stdout={completed.stdout!r}; stderr={completed.stderr!r}" + ) + return result + + def run_construction_checks(*, require_compiled: bool = False) -> list[dict[str, Any]]: """Run construction-time smoke checks for provider classes.""" return [ @@ -640,6 +778,7 @@ def run_construction_checks(*, require_compiled: bool = False) -> list[dict[str, _check_adapter_config_construction(), _check_statement_sentinel_identity(require_compiled=require_compiled), _check_statement_cache_rebind(require_compiled=require_compiled), + _check_service_subclasses(require_compiled=require_compiled), _check_aiosqlite_ambient_exception(require_compiled=require_compiled), _check_aiosqlite_exception_mapping(require_compiled=require_compiled), _check_fastapi_filter_construction(require_compiled=require_compiled), diff --git a/uv.lock b/uv.lock index bb2082fd7..7cdc7a8ca 100644 --- a/uv.lock +++ b/uv.lock @@ -161,7 +161,7 @@ wheels = [ [[package]] name = "aiobotocore" -version = "3.9.0" +version = "3.9.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "aiohttp" }, @@ -173,9 +173,9 @@ dependencies = [ { name = "typing-extensions", marker = "python_full_version < '3.11'" }, { name = "wrapt" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/73/c0/18abcb7e4e504a68714c280853fd180afe376a4a55e5511fb04ba76702e4/aiobotocore-3.9.0.tar.gz", hash = "sha256:5d344e97c518b010bea167c7f7ba4f9e785f9d2b8ac7af4fd00846c62f2c0a10", size = 514972, upload-time = "2026-08-01T11:54:07.673Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a4/0d/98230a1320e78f2c35277ca194c494690dce3161ad05200556417ab9e816/aiobotocore-3.9.1.tar.gz", hash = "sha256:617d4a78da5adb6ae7d532835727ad388f73555f2ef129b9de1b1add73a43ee6", size = 516440, upload-time = "2026-09-07T17:14:07.099Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/30/c5/6290519dec32f3cdf6827e3bbcbf7a9f4fb29a55a9204199901fed69957b/aiobotocore-3.9.0-py3-none-any.whl", hash = "sha256:7354659eac9ba6034675b3ea178330b7de97c45989d6fda1bf01d3da167b6135", size = 100764, upload-time = "2026-08-01T11:54:06.128Z" }, + { url = "https://files.pythonhosted.org/packages/13/f5/20b5c946fdcfafa8e0538d4d278abf10dda4b4012f29aa98a32fe09a46c5/aiobotocore-3.9.1-py3-none-any.whl", hash = "sha256:23aa448b4daff3fdce0714c962a2050b63c0222b5f2b5c17d0c874eb76a50ac0", size = 102044, upload-time = "2026-09-07T17:14:05.224Z" }, ] [[package]] @@ -436,66 +436,66 @@ wheels = [ [[package]] name = "ast-serialize" -version = "0.9.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/fd/c0/5bb6885a9608d86ee5712c0d88bc405d3a49f3e44231576e130ea2f53d34/ast_serialize-0.9.0.tar.gz", hash = "sha256:79fe8be1c934aa572940d1811d8dbe4d1b6f22291e3f16755c9b062e9ac92fb7", size = 951293, upload-time = "2026-09-02T15:50:45.078Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0e/76/497f19d9bdb3899a1efd82e2957f455d0c6e0cb9ebbc254735acb1f74235/ast_serialize-0.9.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:ae1c46eb97865823f9843c4b80145e011874923e1a4a44b45738a5309d83e9f5", size = 889442, upload-time = "2026-09-02T15:49:21.144Z" }, - { url = "https://files.pythonhosted.org/packages/2d/c5/9fb64b7106c5534739322c74be7b743c4f2e3b5fd05d5b8e677f05c54d5f/ast_serialize-0.9.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:af082cb7e6c4fa3a428aa616c13d709a944076eba84a73184de15621cc1a915d", size = 1226721, upload-time = "2026-09-02T15:49:22.612Z" }, - { url = "https://files.pythonhosted.org/packages/27/67/b550fc81aa0133808410783c6d9a1b925e31610d226e836e21337850af55/ast_serialize-0.9.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7e9f2540741ad10657a209209f7e5cc6b530eb3ed145fd77258ab43542d96ad7", size = 1207369, upload-time = "2026-09-02T15:49:23.916Z" }, - { url = "https://files.pythonhosted.org/packages/5c/1e/ed9e66deb7da63e44d0c0fd3a8feef698882ed56ea521a29494d4616eb46/ast_serialize-0.9.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a95485d5e8704af2ecc7f723757b88f992ae8122028d687ccf877cad2b4c3da4", size = 1273073, upload-time = "2026-09-02T15:49:25.336Z" }, - { url = "https://files.pythonhosted.org/packages/68/8f/cd337551d7a68c982425bbf91f183943d7ccc62394002c74807a7f0e60db/ast_serialize-0.9.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b559cffac5a71a698d9194e4295765ff2132a10fd1284860f02b30f12c1f729e", size = 1279045, upload-time = "2026-09-02T15:49:26.75Z" }, - { url = "https://files.pythonhosted.org/packages/40/c6/98dc41eb4122d5da83241e805739838ed59e1e1b9006cbed89ded635a17f/ast_serialize-0.9.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dad8a3f7106efcf252fc289c092ee0cee5c3512c0088bcf3fffa01458323092f", size = 1539300, upload-time = "2026-09-02T15:49:28.213Z" }, - { url = "https://files.pythonhosted.org/packages/9b/d2/d94cede4b3f2a4e329d8ca92218f0846cfcc9257be91c5bf1168671f4ab5/ast_serialize-0.9.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:24de2bc930b7e1ca86641136b9875a1e5f80f52b484deddc67893eeaf9077bd9", size = 1291957, upload-time = "2026-09-02T15:49:29.643Z" }, - { url = "https://files.pythonhosted.org/packages/8e/85/8ac18d754225cf13392786b23d4ba84273ceee562699362f22e61942ce64/ast_serialize-0.9.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ac7b4cdf89ca8318aae157d824017596784982851c8a89a621973f261574696", size = 1291779, upload-time = "2026-09-02T15:49:31.199Z" }, - { url = "https://files.pythonhosted.org/packages/62/ed/cc757fec9e96e29f19a6f818e05147e4f2949356258a3243412756f22a2e/ast_serialize-0.9.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:95dcb93f30258dcf09d9b6a302dac9323b70e9df8c18ee0bf4ea1fa7cc5f1875", size = 1299730, upload-time = "2026-09-02T15:49:32.774Z" }, - { url = "https://files.pythonhosted.org/packages/a7/8c/a575ae0ae954f21a187b4c1d8cec28d81a009693bd13a1388eec72d9b55a/ast_serialize-0.9.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1ed5824b4b2fa37ad93fa2db23d8243a3d315b3e2d7ca70f99b2727d8788af05", size = 1344671, upload-time = "2026-09-02T15:49:34.217Z" }, - { url = "https://files.pythonhosted.org/packages/80/41/0b2b15c0ae5f9a95f433016d1a59a3227eebbb378654d6354206c8ac8e8d/ast_serialize-0.9.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e3c69f2ce565c786bd3853ce42495e8a63610516f79651c7cb4f2cd0ddfaee52", size = 1448527, upload-time = "2026-09-02T15:49:35.68Z" }, - { url = "https://files.pythonhosted.org/packages/18/be/ee89cb6a5d3427946532f0611b514befdd69564803e9a9f9ce712f9d2654/ast_serialize-0.9.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8c824d822a2ac54ec4228b88c0d170ab0024cf285eeee57b9d4f994003fb553", size = 1554045, upload-time = "2026-09-02T15:49:37.15Z" }, - { url = "https://files.pythonhosted.org/packages/e0/4d/eaada807f98a2f0d370fec4b46c84f0e551a62911e751a76ecb32bef4dde/ast_serialize-0.9.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:c55010ea0fafc6bc8231809d328bda781bfe41a01c43522be5eb3713fd855cda", size = 1547578, upload-time = "2026-09-02T15:49:38.791Z" }, - { url = "https://files.pythonhosted.org/packages/b9/0c/046c531f4af4e1bc3314077a84b3099f38b45e2d969faa24acedb3066d92/ast_serialize-0.9.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:322282ac5337e5e776bc416f2b5201e680fa4dacf92ea739bd35e46a28a66c41", size = 1671896, upload-time = "2026-09-02T15:49:40.273Z" }, - { url = "https://files.pythonhosted.org/packages/6b/80/8d32aa0cf4e3e566399b2079a4c47f8ad3c62155f6ee1fe63631b6d3fdde/ast_serialize-0.9.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:ded5ed06ec469407d6cd571ace7a7a25809cc388e4bac1dd35c7747469fc7fdf", size = 1472895, upload-time = "2026-09-02T15:49:41.814Z" }, - { url = "https://files.pythonhosted.org/packages/e6/b9/8204c7e3d8abd4b0c7a56a8d5cce05fcacfd6a5d63ffbd812b8b94040d6d/ast_serialize-0.9.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3ee40752ddb4fb5c6a67161d13f3ce3df7987dcb9272260542a86b0be1519ae2", size = 1492731, upload-time = "2026-09-02T15:49:43.355Z" }, - { url = "https://files.pythonhosted.org/packages/f3/72/ff5c44c19409686798feeb1fbe209f2be78b4b64948d5aa2ddeec8901591/ast_serialize-0.9.0-cp314-cp314t-win32.whl", hash = "sha256:d9c635eacfc02b91da6796d3b5ff9086e511b8a29b19f9b3f4f978b8d170f838", size = 1112847, upload-time = "2026-09-02T15:49:45.181Z" }, - { url = "https://files.pythonhosted.org/packages/20/75/fa5be1a94d189adafadf9c5f07fffd66af7a8061c4cff92f75285ef79d10/ast_serialize-0.9.0-cp314-cp314t-win_amd64.whl", hash = "sha256:62a96e327e2a178d6c295b10422e95c992a9286f0ec1b2bc7cd5b4873252a38c", size = 1146846, upload-time = "2026-09-02T15:49:46.63Z" }, - { url = "https://files.pythonhosted.org/packages/ea/ef/b2bfb331b6e379d435543f6d3be0b590e7a2f441d31ccc17d75f2d2d7cb8/ast_serialize-0.9.0-cp314-cp314t-win_arm64.whl", hash = "sha256:41da4332492222d56345d5e436eed4fbec76caadee959f6ffa3cd2fc1bd51895", size = 1119605, upload-time = "2026-09-02T15:49:48.14Z" }, - { url = "https://files.pythonhosted.org/packages/e5/f9/a4af1bf8b35927814c09d90c3965dbfaa75c489ba34372bffafbc2209f40/ast_serialize-0.9.0-cp315-abi3.abi3t-macosx_10_12_x86_64.whl", hash = "sha256:383f56e3ae925f154632458f01b4bfcde3dd382f3ec04f5c7f6d72f76524ff48", size = 1226344, upload-time = "2026-09-02T15:49:49.79Z" }, - { url = "https://files.pythonhosted.org/packages/1d/6d/d3a95823a803c21f5c9df595a0bb93aada22e7aa22bf875fe00d89422d7f/ast_serialize-0.9.0-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:b9ef3d4173907bd19aa8f1683be9f06e7862e6cdf2ca6bca3633305c0df32063", size = 1207384, upload-time = "2026-09-02T15:49:51.22Z" }, - { url = "https://files.pythonhosted.org/packages/f0/97/6e7f46c8455b738609c29d1b7655307a168c4b40ce4c7a2c678c8ed9cf2e/ast_serialize-0.9.0-cp315-abi3.abi3t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9482672ca8ec09f85cd050a053fb88c30c882c8e20ce7a140d8defe19c0ef2eb", size = 1273139, upload-time = "2026-09-02T15:49:52.679Z" }, - { url = "https://files.pythonhosted.org/packages/f0/6e/25b70733f061766865cb04d913dc5332037c595796b871d52ab5b569abb8/ast_serialize-0.9.0-cp315-abi3.abi3t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a6a568d1d489f0669a31aed90ca4845aa7f08e1b8cd5d05e1905dbdc3ae9b2b0", size = 1278242, upload-time = "2026-09-02T15:49:54.236Z" }, - { url = "https://files.pythonhosted.org/packages/9a/f0/b7820399d9c5a0b7f07c239b6da93d2e21a1b3785137fa00e16528e414b3/ast_serialize-0.9.0-cp315-abi3.abi3t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5a4dd005d4095a13eb312dc712c943c7730f262b000a87df963925328a38ffdb", size = 1541009, upload-time = "2026-09-02T15:49:56.149Z" }, - { url = "https://files.pythonhosted.org/packages/08/56/5146f1d2a77516e697f6f42825df79137e43560675cb4605c467775f8b4a/ast_serialize-0.9.0-cp315-abi3.abi3t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:207ac73afa1f4654840593853c130eac2591dd942434176eea33f730afb3359b", size = 1290898, upload-time = "2026-09-02T15:49:57.502Z" }, - { url = "https://files.pythonhosted.org/packages/69/c4/87cd16228796d703de795a369b90b0f57f0f017f90f55c4c5876e3513a03/ast_serialize-0.9.0-cp315-abi3.abi3t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ae01129e2cc5d57a3c434d8a990019de039350310a2e1dd3c9f61311964cf25", size = 1291742, upload-time = "2026-09-02T15:49:58.982Z" }, - { url = "https://files.pythonhosted.org/packages/cc/eb/13465c297268c5170b2bb746d75f37a8fad44a94a89b593071affc1071d0/ast_serialize-0.9.0-cp315-abi3.abi3t-manylinux_2_31_riscv64.whl", hash = "sha256:4c522377f383670abfe21c94edc3032cb3bd34d8fcacd280fa9556907d4edd4b", size = 1300180, upload-time = "2026-09-02T15:50:00.454Z" }, - { url = "https://files.pythonhosted.org/packages/0a/a7/10b84c4274b2507b0ed9cc1654058ad64bcedb6ac574753d6a461bc6e204/ast_serialize-0.9.0-cp315-abi3.abi3t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4cd886f6e900f5e13f758cb8ef359652e690e4f3f9c257a7269e095940534167", size = 1345857, upload-time = "2026-09-02T15:50:01.875Z" }, - { url = "https://files.pythonhosted.org/packages/c7/dc/2702182c9773a15de9aabfaf66da7cb87548a56a6bac24f0c9176a4a13c3/ast_serialize-0.9.0-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:f3f0f3359cf0f22bf096b07021ffe6bf0ec88ac8a2cf7ce5f4701af973112faa", size = 1448544, upload-time = "2026-09-02T15:50:03.496Z" }, - { url = "https://files.pythonhosted.org/packages/59/b5/eeef2124c9563b9861707ef4db91f153f3bb37b3e0cca9543bb88a4e9e53/ast_serialize-0.9.0-cp315-abi3.abi3t-musllinux_1_2_armv7l.whl", hash = "sha256:6c428444656cffbd32c1e76626c6eec5237b58c8fcb0b5d3df75941cd50c4f3c", size = 1551572, upload-time = "2026-09-02T15:50:04.982Z" }, - { url = "https://files.pythonhosted.org/packages/cc/8c/81d18349f1dffdcfeb80671bd737e342c86348e183692d9d0d8f573d1385/ast_serialize-0.9.0-cp315-abi3.abi3t-musllinux_1_2_i686.whl", hash = "sha256:54f0babed5e2a4eb86a0716ac612aff33f933e7572e5bc067adcdbe672a26321", size = 1548118, upload-time = "2026-09-02T15:50:06.522Z" }, - { url = "https://files.pythonhosted.org/packages/d4/1f/339131b60d1b0df13d9f3470cfac70f858b5649188ea01b2e7b39caeb720/ast_serialize-0.9.0-cp315-abi3.abi3t-musllinux_1_2_ppc64le.whl", hash = "sha256:1b779fdaee34d19900a5ba5fd6bd4cefe225650081f9de28de256eacee5113c2", size = 1674707, upload-time = "2026-09-02T15:50:07.919Z" }, - { url = "https://files.pythonhosted.org/packages/18/0a/ca77596fa229d88f96eca180d45dbe8efa11306f8b2b4f4ee301b3fe465f/ast_serialize-0.9.0-cp315-abi3.abi3t-musllinux_1_2_riscv64.whl", hash = "sha256:4db7f524eaa857fbe650cac33b9cedb5ccda14393d40f640b75dfb06aa13c98c", size = 1473618, upload-time = "2026-09-02T15:50:09.312Z" }, - { url = "https://files.pythonhosted.org/packages/88/5c/6aebeb54dd226b480014ff4488e150aa23b1de3204e2bf3f87de27e6542a/ast_serialize-0.9.0-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:d2a37795a90809da6094825e7063118b4cf723b8701b134973b4566ed8b9ea09", size = 1492025, upload-time = "2026-09-02T15:50:10.755Z" }, - { url = "https://files.pythonhosted.org/packages/75/e6/c355d470a230f778311c28b80f6d934a497d094139f07230433eea18651b/ast_serialize-0.9.0-cp315-abi3.abi3t-win32.whl", hash = "sha256:4411d1cba9eeecb301365343a7e96813b4a44fcdb20181557867ff7e751804cf", size = 1113010, upload-time = "2026-09-02T15:50:12.337Z" }, - { url = "https://files.pythonhosted.org/packages/fe/0d/66609ace58564727b68731293cc986c2ea1d5e6ef40e96571e7fb515f0af/ast_serialize-0.9.0-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:b5c3724faf780e25def89c369eb6340a15dff06ac348160c61781e2373a4cd10", size = 1146404, upload-time = "2026-09-02T15:50:13.761Z" }, - { url = "https://files.pythonhosted.org/packages/b1/fd/da28e1c85f05fb9976f247d2a3aefce68866cb2939abcbdbddd9a5e3b835/ast_serialize-0.9.0-cp315-abi3.abi3t-win_arm64.whl", hash = "sha256:1de0933a4c1d104d77d6e75f053f5e628b54cf8f9fea809b8250cb04cda07bd3", size = 1118328, upload-time = "2026-09-02T15:50:15.214Z" }, - { url = "https://files.pythonhosted.org/packages/ba/8b/487a158a99e4564244e000ed18475255dfea53fd34a84d8ca73633710500/ast_serialize-0.9.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:5fc57f17fb4ce49b4eeccfcd2670e4a55659bd740bb8e8aedbe511ccab8b5f03", size = 889484, upload-time = "2026-09-02T15:50:16.643Z" }, - { url = "https://files.pythonhosted.org/packages/92/e4/175b0a64d6c96bc1b96598c6474ce8d1ef34e0b774bcf7183f4ce696fb10/ast_serialize-0.9.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:dac690f99538d9df0d23ce0299e946add2744b007a36b480a292fe361c82553d", size = 1232635, upload-time = "2026-09-02T15:50:18.133Z" }, - { url = "https://files.pythonhosted.org/packages/28/0c/d51d8463aca43aaa833fdf1f25134d6cc1b483764896decca61306ad1f6e/ast_serialize-0.9.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:2223ead73b5a5399d39610cf9c4164ad0b2bf2025226626b87ae15226d93d3f7", size = 1219313, upload-time = "2026-09-02T15:50:19.497Z" }, - { url = "https://files.pythonhosted.org/packages/ef/19/c88bdc64f86095a9d6ab325ae422b2a5e1395cd63cd8aa539003d4d4ae1d/ast_serialize-0.9.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b7c5f5838408fb000d76abd14e886836412b7ec7eccd028dbb5ed5819780008", size = 1279981, upload-time = "2026-09-02T15:50:20.811Z" }, - { url = "https://files.pythonhosted.org/packages/86/58/a492075826df1753896dc8e8f6ababae4016d8883b670ee3a1c34788b154/ast_serialize-0.9.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1e05701fde79affa1cc53e391867f9da3eb03fa8501f87354292796b0f8398fd", size = 1286319, upload-time = "2026-09-02T15:50:22.203Z" }, - { url = "https://files.pythonhosted.org/packages/ae/79/3f6754eaa42fd2a6c36aac066890870cd44cbe0e25f75a67b1b99a2f4d82/ast_serialize-0.9.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d013c36eb2f2ac0cb7d4d0e79918a92ab00fbce8f1542fe47f34a46e06168f82", size = 1551547, upload-time = "2026-09-02T15:50:23.528Z" }, - { url = "https://files.pythonhosted.org/packages/b1/05/8cfb7caadfaf28febaa6b61d31d778262f87f9366eda4dd9bd07ac940b75/ast_serialize-0.9.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:19cde5c2110f7b90ab1210a599178524f6c9f34862b20ba2b9aa7832c67bb35d", size = 1302468, upload-time = "2026-09-02T15:50:24.99Z" }, - { url = "https://files.pythonhosted.org/packages/aa/e2/750a0b136bb02ff8e4a17d65a3a78cd478ee50724704df8215797a226ba3/ast_serialize-0.9.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1514f4a39704e2e815f9fc675fc13f19f694f212086b520110840782cf3c5295", size = 1300563, upload-time = "2026-09-02T15:50:26.354Z" }, - { url = "https://files.pythonhosted.org/packages/ab/17/4c0aa852ff1e4f2d6723e8ce827136c1e1febf2845d7941ccc45426778de/ast_serialize-0.9.0-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:30651ccdec6d23c49ee4711b1a1096d8dbd3be38eecf2f09fdd98a608ce7ac24", size = 1308999, upload-time = "2026-09-02T15:50:27.901Z" }, - { url = "https://files.pythonhosted.org/packages/4d/1b/6e73d0a29aedb0db30cc68f2557acaac06cd24c9783ccb90f84f89e4ce87/ast_serialize-0.9.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d9a46caf5e3f2cd266e8638b2f4ea8bf54cf376f015f8418397b4633fdb38e9b", size = 1358191, upload-time = "2026-09-02T15:50:29.237Z" }, - { url = "https://files.pythonhosted.org/packages/dc/38/2cf5d552de99e0e9804a16fea73e54d0a7382498adddf57c0f6dc09cbc70/ast_serialize-0.9.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:aed6e413c6c22a23c33c47a01dd2adce01d7a7ed408748e896903f47d0a1aa47", size = 1458944, upload-time = "2026-09-02T15:50:30.77Z" }, - { url = "https://files.pythonhosted.org/packages/4b/0b/5ef87adf955b6a027f616eb7b55f55a154c35ba600e9dd2d06ad2d30e5c2/ast_serialize-0.9.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:871fb7c5b049897ee137b67efad7fe4545ad270f7eccd970da877833f8e63aa7", size = 1563421, upload-time = "2026-09-02T15:50:32.188Z" }, - { url = "https://files.pythonhosted.org/packages/81/dd/9ced05a17feeb0f83e84010d80f5a1b7b7aa19e75f0376f4d3780803654c/ast_serialize-0.9.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:bb378efb5537b43f38660e2e6d6e138a40885cf191d43443bb3ff7ff47e9cd9b", size = 1558536, upload-time = "2026-09-02T15:50:33.861Z" }, - { url = "https://files.pythonhosted.org/packages/5f/8b/8ad486e44fc7081a2471055befc433dddc2e51c3a88dff141b3026f64602/ast_serialize-0.9.0-cp39-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:b373beff65b01fcffca5aaad3269ae629f3a998b09efdd3635e48039008a5dec", size = 1682749, upload-time = "2026-09-02T15:50:35.257Z" }, - { url = "https://files.pythonhosted.org/packages/dd/4c/7c282aba9cfb0b92d79fac45c04e4557d9a7f08d872e5a43577a50867e30/ast_serialize-0.9.0-cp39-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:25c8d517c45cf2b1820fc2af6ac593783654818f79d05646d25d624360678a4e", size = 1482441, upload-time = "2026-09-02T15:50:37.319Z" }, - { url = "https://files.pythonhosted.org/packages/a4/3a/e45914e8cad81b660915f3784d255460a6384183b76bfc2089fdd79ec7df/ast_serialize-0.9.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:1675dc46578298ae00936164a160997801a6ca2385913150d8d16df634296cf3", size = 1499042, upload-time = "2026-09-02T15:50:38.76Z" }, - { url = "https://files.pythonhosted.org/packages/99/09/6988921dec19c810beef53539fec2e90ae551cd93853b3303a99fe45f772/ast_serialize-0.9.0-cp39-abi3-win32.whl", hash = "sha256:20fce3885eeff05a3d6afefa845c8168016e3ea1f6fc9cdc84c8db28b863a550", size = 1116391, upload-time = "2026-09-02T15:50:40.229Z" }, - { url = "https://files.pythonhosted.org/packages/fd/eb/839598a22a1f9af56d39e188451cad93dbcb0ce6539a45ac18fb8bf123fa/ast_serialize-0.9.0-cp39-abi3-win_amd64.whl", hash = "sha256:161914666a21d48b681982146ac0fa4086ef099d91c637cf595387f5f06aa099", size = 1156055, upload-time = "2026-09-02T15:50:42.05Z" }, - { url = "https://files.pythonhosted.org/packages/0d/45/c7cd8d36d3b506bbd02db5066fae3340284781168f0d08dac25deef5f69d/ast_serialize-0.9.0-cp39-abi3-win_arm64.whl", hash = "sha256:74473258a5c55855d5306c864a5c799fbff03a0f0ea1197346b2b5cc5b4ea48a", size = 1128237, upload-time = "2026-09-02T15:50:43.496Z" }, +version = "0.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/59/6d/c6ab91f72f4862d63e446e10248d8f52e8b4c4b7579bb937ddf942a5961e/ast_serialize-0.10.0.tar.gz", hash = "sha256:f47a26cc7d2605fb645b6e7f6c21cf4fb8d7833d00ea8b48e26f057b14eccd01", size = 952608, upload-time = "2026-09-07T10:22:47.595Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/cd/0b7ede86065c89d56c533cd98b8997f3dd3f003bc01815c9c41860724d6c/ast_serialize-0.10.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:2759bc9e04b13f11b80a23a7aec8da16a27217e0f4bf61019f06ea533511d2ed", size = 894424, upload-time = "2026-09-07T10:21:17.374Z" }, + { url = "https://files.pythonhosted.org/packages/b9/62/012afc9f7177e181c7d23ef2b0b974c9a0a800321de5cf663bd372894d4e/ast_serialize-0.10.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:2eef5883e824ff7d303be13ca1dd1aaeb1975ac9f3da5ceecb3ae43c84a54773", size = 1229989, upload-time = "2026-09-07T10:21:19.536Z" }, + { url = "https://files.pythonhosted.org/packages/ea/76/67774bf7f22166f7609861d85d8350e465eab7f92461d4c4ab808de398e7/ast_serialize-0.10.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6ee514e465bd43dddc6b0b1d05b5baf64035b5f945ae558d4f1021b368f1c4c1", size = 1209345, upload-time = "2026-09-07T10:21:21.228Z" }, + { url = "https://files.pythonhosted.org/packages/d2/c7/238063d1b2797e43d3704c5a280faae003348a10bbb6d08b55a843c42fd4/ast_serialize-0.10.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b910e8c67547efe5a5d5524de7ce80dc50a45debafaaf4b29000fc72b34a8902", size = 1274910, upload-time = "2026-09-07T10:21:23.425Z" }, + { url = "https://files.pythonhosted.org/packages/b2/48/1de96ee95d0069615ff7e1664a71b4e6b4ccf3f16b5e1a3ec1ab66f3788a/ast_serialize-0.10.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0103ce489e91b0467cc2bf2fc7eaf80b7b61d5e48aed070a9c3d594e41dffaad", size = 1281284, upload-time = "2026-09-07T10:21:25.184Z" }, + { url = "https://files.pythonhosted.org/packages/fb/03/a33aa714487acd858eaa192099ab18c28a711d2f192606de1fc174d8b0e6/ast_serialize-0.10.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cc1e7e5b6db230c980a2916350d07f9b7ad6f08fb1ab6932bd393aa0c6d9220", size = 1547608, upload-time = "2026-09-07T10:21:26.913Z" }, + { url = "https://files.pythonhosted.org/packages/88/11/9bf2e23bfa848033ba3faedab51a8f3104d90e58222ec32eb476b18cc97c/ast_serialize-0.10.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:226535f407b70f22109c5faf777cb5c8e9189bf44f29b2fb4ba87093c2c01743", size = 1297685, upload-time = "2026-09-07T10:21:28.418Z" }, + { url = "https://files.pythonhosted.org/packages/4e/ba/6175b12119b1605b2a888318cfcbda260947c002ba7c6921b053606c6751/ast_serialize-0.10.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8274eebef548a927c3691c7f7c2f4635dde700164ce942273a464cc914241ae9", size = 1295877, upload-time = "2026-09-07T10:21:30.414Z" }, + { url = "https://files.pythonhosted.org/packages/d7/81/80f5c2b313efa1397ef2dab6e76c321ec05c2c256d0ea5e91232835c86a7/ast_serialize-0.10.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:6c944147c80cff8cfad185835bd4772c690019988331f05095d1d5f393eefe06", size = 1302152, upload-time = "2026-09-07T10:21:32.06Z" }, + { url = "https://files.pythonhosted.org/packages/fd/fb/e64b8081a5aaf1ebf189a9c4c3c1be771eb7e2a4e42009cb7a91d4647753/ast_serialize-0.10.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6760026ee6903cd63d89e77a0cb9ea4f150fe619ec541b8590bcaacf26dfbb81", size = 1349550, upload-time = "2026-09-07T10:21:33.614Z" }, + { url = "https://files.pythonhosted.org/packages/5d/17/9665016237be55439435b7eb809c65fbfcee6f0a94b67670c85d57674329/ast_serialize-0.10.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f72062e17859d9cbf946fcd6b2d7b20d79a4fc5dc51e28198d86c6455cd1ed4", size = 1452798, upload-time = "2026-09-07T10:21:35.148Z" }, + { url = "https://files.pythonhosted.org/packages/07/77/66110e38d406d148986698a9e53ec0f5e3798b88b4483636469edefc492b/ast_serialize-0.10.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:0eb4562df6842d900b127c59c2896e8684e2a5eb69518cc79bfa24ec0b6bd808", size = 1555553, upload-time = "2026-09-07T10:21:36.722Z" }, + { url = "https://files.pythonhosted.org/packages/db/ba/a8ad46ae9510e7a9cddc21ebde3fa465ac4be863984c011a5886870a1d4d/ast_serialize-0.10.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:2afa657d7ce1a1e150dfa4794d1d303441bd17367d69941f9712c15e4d273b3c", size = 1550516, upload-time = "2026-09-07T10:21:38.215Z" }, + { url = "https://files.pythonhosted.org/packages/7f/dd/cb9d394e17eff38adc141983ba503ee12d3851c1a0f6c319e9228f5c5e81/ast_serialize-0.10.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:7ff5abf0897f54d62bd32a2878bb154d648ceaf77f553ff39b264c1191b0d60f", size = 1679774, upload-time = "2026-09-07T10:21:39.766Z" }, + { url = "https://files.pythonhosted.org/packages/75/a2/ad4f80989c179ae73c6e44ed1bb215c39c220071e7ccb88d28e4651508f0/ast_serialize-0.10.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:6f8b8a4c4e02d1bea4e2212727fa6ddf824d8c5926df03452ad491470ce37699", size = 1477137, upload-time = "2026-09-07T10:21:41.318Z" }, + { url = "https://files.pythonhosted.org/packages/e5/b5/4f193b9513161b109112fa5ba47fda0885cec6fa3f419317e15ea6583ff9/ast_serialize-0.10.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:84bac4b6f441824d91e0540362f12c0e0f8820294652521b4ce9d7e7faa56b5b", size = 1495387, upload-time = "2026-09-07T10:21:42.882Z" }, + { url = "https://files.pythonhosted.org/packages/c7/bf/adfe52b8be218ecc9a7e57fd217ede236e37421494f974791dc3939f1267/ast_serialize-0.10.0-cp314-cp314t-win32.whl", hash = "sha256:15bd638e70753e58b3d1f2859dfdeef268bc9ebfd349c5acf477bad01cb97cfc", size = 1114335, upload-time = "2026-09-07T10:21:44.635Z" }, + { url = "https://files.pythonhosted.org/packages/ec/ed/a7658ffbe64eb0a61fdc936dd33877d6233d4db6a757ae0c19b6e0bdf74e/ast_serialize-0.10.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4cb6d447b3510e47090b66560e17a466f3d61e42699c475482b505fd80ff8c83", size = 1150487, upload-time = "2026-09-07T10:21:46.401Z" }, + { url = "https://files.pythonhosted.org/packages/cc/0b/fdc76a035cd036d3ae5ad189247879bc3582742ba2267f4f79fbd16023a2/ast_serialize-0.10.0-cp314-cp314t-win_arm64.whl", hash = "sha256:efde0f316f226d4e7b211d62bc0cc17f6b4cd2d057622b889183a38956d0f9ce", size = 1121949, upload-time = "2026-09-07T10:21:48.1Z" }, + { url = "https://files.pythonhosted.org/packages/ac/bd/cf2deab2ceb79f4476a30479a2756bb64b63810b7f10bfbd3ce1503d4059/ast_serialize-0.10.0-cp315-abi3.abi3t-macosx_10_12_x86_64.whl", hash = "sha256:cbcc3542259ae08153e634d50dc220723415fb24510856523052b5eeb10b4950", size = 1229414, upload-time = "2026-09-07T10:21:49.554Z" }, + { url = "https://files.pythonhosted.org/packages/ee/cb/ec8e84d3ab8073e8536823f7a3cba46e4992d9c8d904481e18509eeea3ff/ast_serialize-0.10.0-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:2251086be53a375d256faefaedffe5ccd99187be614788f8279b41dae1c5fdee", size = 1210297, upload-time = "2026-09-07T10:21:50.996Z" }, + { url = "https://files.pythonhosted.org/packages/6d/e7/6a1d216160da29566a6125c34e90092a5f9d1444e24e955741113abdf033/ast_serialize-0.10.0-cp315-abi3.abi3t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1358ef5d98f9dc96468d171317d78d746f9ef8ca45577298512a737ba9d6514", size = 1276064, upload-time = "2026-09-07T10:21:52.452Z" }, + { url = "https://files.pythonhosted.org/packages/96/87/1f1052a0dd00dfe15c129a7073f7b1b5bb632b5507baff27190dd255e0a9/ast_serialize-0.10.0-cp315-abi3.abi3t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:59ef8acc0ba4315024e5000e5fa8ea656a02e375ebb5ce020f3582d308d6153d", size = 1280982, upload-time = "2026-09-07T10:21:53.992Z" }, + { url = "https://files.pythonhosted.org/packages/d3/8f/9f4578b668b60436249dfa1bc6612283d3cbb665bc6cb2c1e23934d708d8/ast_serialize-0.10.0-cp315-abi3.abi3t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3c9715c4379b33740c94819e55afe59e28d6d3f30f69b903b4fcb2ecb5335531", size = 1552458, upload-time = "2026-09-07T10:21:55.485Z" }, + { url = "https://files.pythonhosted.org/packages/e6/cc/395d96c55e5d91a87fcfa5f15c7d11834cd150d491ce4849b2290334b8e9/ast_serialize-0.10.0-cp315-abi3.abi3t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:26e6dc5d1f7aa642d9e94b98e4d3e1c81dc6b595f01619658f7e9268379826c0", size = 1298414, upload-time = "2026-09-07T10:21:57.01Z" }, + { url = "https://files.pythonhosted.org/packages/7a/8d/473c8fb551af1de55abcc36d591ac18d4175ba7fc15f41d62ad9b30d7385/ast_serialize-0.10.0-cp315-abi3.abi3t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:760dce78c6c4d4df30d3df9b80be1c521e0ee1d275ae54906e9a95b150692567", size = 1296613, upload-time = "2026-09-07T10:21:58.591Z" }, + { url = "https://files.pythonhosted.org/packages/6f/57/31044aa6fa739634ada7fff321db08a813157663b18629851820fca455a6/ast_serialize-0.10.0-cp315-abi3.abi3t-manylinux_2_31_riscv64.whl", hash = "sha256:40a7f487e2f5523518270600e0b7f2c61beac3106da142d911c3386ed7abbcfa", size = 1304321, upload-time = "2026-09-07T10:22:00.12Z" }, + { url = "https://files.pythonhosted.org/packages/10/87/c5d7c0c627b991f46fc308a41c0e92b792322440f84e43739b11fb4a1a64/ast_serialize-0.10.0-cp315-abi3.abi3t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a1c252b746da0ad1883b82502eeff859221eef1d66d3f95dcb2373760a34d440", size = 1350352, upload-time = "2026-09-07T10:22:01.605Z" }, + { url = "https://files.pythonhosted.org/packages/62/ec/d80abe681b7d96b4ea88cf69d559d55a41b1a36c907b579d774caff2527a/ast_serialize-0.10.0-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:719c7a121cc3022d78b7f4f7a9fd159586e521531c0e495a245375d2c4695d4e", size = 1454522, upload-time = "2026-09-07T10:22:03.149Z" }, + { url = "https://files.pythonhosted.org/packages/8d/7a/d4cc3aa236b9fdce16a394bfd7c12072d9ac30e83f9319aaa14305cbaab9/ast_serialize-0.10.0-cp315-abi3.abi3t-musllinux_1_2_armv7l.whl", hash = "sha256:d7621157ac99ae00957196e7094fe279e7547d8b505046a9d5509c4fc740e9fc", size = 1555150, upload-time = "2026-09-07T10:22:04.722Z" }, + { url = "https://files.pythonhosted.org/packages/d2/a6/710d1aef678650c75edcb4cdab79998ec63aae54710a438b9fd66c3a616e/ast_serialize-0.10.0-cp315-abi3.abi3t-musllinux_1_2_i686.whl", hash = "sha256:82087a71fe39925ab0068ef2f25444a1c87d1e5f1901f32dcf82f6eddddeac6a", size = 1551843, upload-time = "2026-09-07T10:22:06.182Z" }, + { url = "https://files.pythonhosted.org/packages/e9/23/2a9c35721a82a506bae980dbdfeaa7b296bf79d818c731b3aaa0ee53c5a7/ast_serialize-0.10.0-cp315-abi3.abi3t-musllinux_1_2_ppc64le.whl", hash = "sha256:8aac958cf0c0b2595a0487c7b5d2ecac88fa5c0221b83b1420ac4bf472f84cb7", size = 1686064, upload-time = "2026-09-07T10:22:07.712Z" }, + { url = "https://files.pythonhosted.org/packages/24/36/f3fd4b6f2c1e4d5eca149e4bfdaa6d93fe77851b21562d14f22a452c71ee/ast_serialize-0.10.0-cp315-abi3.abi3t-musllinux_1_2_riscv64.whl", hash = "sha256:a53a4d528171b8b709b4e7d89654532189bff53947f24ac4db9c465bb10e7cd2", size = 1478662, upload-time = "2026-09-07T10:22:09.218Z" }, + { url = "https://files.pythonhosted.org/packages/de/65/5135ac9c7e305bd3e6234ef0fbf50bbac2ac00a35076bc167936c6d6d166/ast_serialize-0.10.0-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:93ae740c6d6f5641573122a7dcffa4baa7ef9144109c54584baad5bf827ad388", size = 1495057, upload-time = "2026-09-07T10:22:10.742Z" }, + { url = "https://files.pythonhosted.org/packages/5a/dd/7dd0e80551dc66fc56197b5439d76fb6173ccf9975df6bf1399e2231069c/ast_serialize-0.10.0-cp315-abi3.abi3t-win32.whl", hash = "sha256:4d10d8fb4b82d5bae455ce9f606920d8dcd563b812b43dcd8d6f9b11089cfb23", size = 1114912, upload-time = "2026-09-07T10:22:12.675Z" }, + { url = "https://files.pythonhosted.org/packages/72/83/a84661b89065fe4986d183abdf0bce5f1a24bea26bbe74054345758357c1/ast_serialize-0.10.0-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:5917460c0f8322755872db1792788fcaa3835d1fb6a3f129c65ace700c7e4663", size = 1152503, upload-time = "2026-09-07T10:22:14.159Z" }, + { url = "https://files.pythonhosted.org/packages/f6/c0/95bc047bc830f3223d42111ca2980a4328cd09d597773f04f2c689c3330e/ast_serialize-0.10.0-cp315-abi3.abi3t-win_arm64.whl", hash = "sha256:8efb53cf1c439516a563664e014ba9b6b4fd86b4869c180954edce3954a51870", size = 1122527, upload-time = "2026-09-07T10:22:15.656Z" }, + { url = "https://files.pythonhosted.org/packages/21/56/f4c5811fc6e765a3c9b1b5dc64d58073e825b8a538773699ec02c2b98d0a/ast_serialize-0.10.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:7272522ca885c0091b4f4165b9403eb54a59e157a248592cc2539098c7ada50b", size = 894552, upload-time = "2026-09-07T10:22:17.27Z" }, + { url = "https://files.pythonhosted.org/packages/70/85/4606f3398e6776c74d44f8387855775c3cf31614b664cdb0e147df752933/ast_serialize-0.10.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:382cb721e2624dd1c2f4f7afd2a9b500930b057d2e24e1078cf6999c5fad1b31", size = 1236237, upload-time = "2026-09-07T10:22:18.767Z" }, + { url = "https://files.pythonhosted.org/packages/09/7b/520b33339f3d5ef9407fb17a00dac0849318158fa0c9853cfe8cc6b7a48d/ast_serialize-0.10.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:56a28b7567ba17f602a17d5603133a1292d307e957b3b5c3f66538e87548aed3", size = 1223110, upload-time = "2026-09-07T10:22:20.243Z" }, + { url = "https://files.pythonhosted.org/packages/a0/af/3c30941ed368ddb54e6ec0edfdd98dc7fdc679c6d4f478f8545c0b8f080a/ast_serialize-0.10.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8919e79a4525cdac63d51cd117c57f324936c902c7ecd0fd09d02aa88323b74d", size = 1285870, upload-time = "2026-09-07T10:22:22.019Z" }, + { url = "https://files.pythonhosted.org/packages/56/81/f0c0bf569388d319aab22c8a7f43747450e26c5ae6a6d9521766157f70f4/ast_serialize-0.10.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1109077d53b377d022d799bc4b171c32c3a711a716248a918d3e07875b5513cd", size = 1290793, upload-time = "2026-09-07T10:22:23.562Z" }, + { url = "https://files.pythonhosted.org/packages/c4/a1/515a76479ecfc77abe88d7c9954bc3a04f07b30fa33ec836eea80be07fd4/ast_serialize-0.10.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5d17c50e1f6e8d950d79c66a18b863dee16cea3106f597203883131dd9c6ca4f", size = 1561250, upload-time = "2026-09-07T10:22:25.057Z" }, + { url = "https://files.pythonhosted.org/packages/4f/ba/702af61eb7a6803bf4cd30c09041ab4212e63d553ed9dc2793c95ab340b4/ast_serialize-0.10.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cf2c6cc5a62839869317523e0f74737db0d1759d72fb62cffe57a40e040d6a55", size = 1305696, upload-time = "2026-09-07T10:22:26.612Z" }, + { url = "https://files.pythonhosted.org/packages/31/ce/e6e0a311c16f84f13528f1cb32dec1ce68102711070c10c0c688a6c3cdf5/ast_serialize-0.10.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb1b20121a62da5937b0c11c8f31667be0102342bf55459bb44a10d8549f8f3f", size = 1302712, upload-time = "2026-09-07T10:22:28.088Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a2/7fd715228a35fec1c587c8156eaabf37b6df98fea48c90eec8f1af362e20/ast_serialize-0.10.0-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:6e45f7d7a663c28ed44d52b4069e32335edb7a0653a908a43bef2801d8d7c344", size = 1313977, upload-time = "2026-09-07T10:22:29.642Z" }, + { url = "https://files.pythonhosted.org/packages/1b/ff/e1c6a0aefdc80695c2dda0c558d58f90f55cb7bb791545865cd7d4ec39d7/ast_serialize-0.10.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5c75ed7d94660e3ed4fd3c35672ab16c248c0be51d6b845de3edebbb6cf4526c", size = 1360341, upload-time = "2026-09-07T10:22:31.289Z" }, + { url = "https://files.pythonhosted.org/packages/08/ef/ab341936f65b663e4909dd5d8772d7c13dd7a39616cf18fd6231197b8177/ast_serialize-0.10.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:45cfbde7e43a56a386b47f13b415d1fa4421b0a5e07ae0c84a7d883ac9aca4b2", size = 1462406, upload-time = "2026-09-07T10:22:32.823Z" }, + { url = "https://files.pythonhosted.org/packages/74/08/1cef69ee4228cd82b9da6b5e29e7fcdd30a6b8b3d6332815781e09666b62/ast_serialize-0.10.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:b3a52baa4c457d17a5729aa9bd698da8e61731f1670b4fe33923da54daa480e3", size = 1566792, upload-time = "2026-09-07T10:22:34.381Z" }, + { url = "https://files.pythonhosted.org/packages/d2/01/a3d773d0fe1536485069953d54bece7d8a95aa688e64f5cd692f68949051/ast_serialize-0.10.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:c07cb3f354c234cfacf81da95194b085186d7f4c1f7ad06c7f04fb49e320ef6d", size = 1560873, upload-time = "2026-09-07T10:22:35.844Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ba/7fdda55197f06b2a1613d2ed7e647035b40b26b7aff62ac78e6728128ce9/ast_serialize-0.10.0-cp39-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:8c91b2bc42a12252be53966a1f1b14cc5c843dfca82bee3bce38f2e96b327aa6", size = 1693061, upload-time = "2026-09-07T10:22:37.355Z" }, + { url = "https://files.pythonhosted.org/packages/3a/29/630a7cafd2780651ed73d468518be9d08a6cc3e7c30fdc88c0b2b90c1c5a/ast_serialize-0.10.0-cp39-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:cb698ad6625a55d5d618c9d887423fd04d65dc5ad0f3ae5a8cbd96c46cea2438", size = 1487731, upload-time = "2026-09-07T10:22:39.403Z" }, + { url = "https://files.pythonhosted.org/packages/a9/c3/84fc44b110ee10fb410d49f7f28686c4d23637161b6cb08775c1af8a4507/ast_serialize-0.10.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:4496c0d20111a243525cb074a3e9a9313bbd7d3fb1d40ddee2ade9ef680b80c6", size = 1501731, upload-time = "2026-09-07T10:22:40.958Z" }, + { url = "https://files.pythonhosted.org/packages/59/9d/eedfd5a8cbeffd7172281e14d7a7e7640ed3997b3a09382c7756e39a2bbd/ast_serialize-0.10.0-cp39-abi3-win32.whl", hash = "sha256:ca5ff9030b426b245cf7897137872cdb6ebe43b2e4c5e04d5812ed24955a91ba", size = 1121201, upload-time = "2026-09-07T10:22:42.629Z" }, + { url = "https://files.pythonhosted.org/packages/a9/83/2db45120bd0ae66cfcd5e235d4dd29aec564e56440ebb17ec83428bb2685/ast_serialize-0.10.0-cp39-abi3-win_amd64.whl", hash = "sha256:f1a8508054137a1cc67a64915ba588e75f03f546a9b16424aaf0cc9854b0a2a2", size = 1158429, upload-time = "2026-09-07T10:22:44.546Z" }, + { url = "https://files.pythonhosted.org/packages/53/f4/3850ee0050b68f3bd31c06a70cb065f7b129123e5795ff8a0ef642db71da/ast_serialize-0.10.0-cp39-abi3-win_arm64.whl", hash = "sha256:354d12c7463266f2ca655af6f0333ee91ea98c875ffc5f47f10f03c7fe8a0667", size = 1130605, upload-time = "2026-09-07T10:22:46.082Z" }, ] [[package]] @@ -733,25 +733,25 @@ wheels = [ [[package]] name = "boltons" -version = "26.1.0" +version = "26.2.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/47/99/12bace94ae2ba961bdc46d49277ff15d38dba074bc3987b0c0b4355a37a7/boltons-26.1.0.tar.gz", hash = "sha256:5764468aba493b15995ed17f46a16789023f123ca2a62d491a9ce825c1cbe26c", size = 227393, upload-time = "2026-07-17T18:38:42.454Z" } +sdist = { url = "https://files.pythonhosted.org/packages/71/56/14c4a4931910a81ddeccfbe227925ea738e3c445d3e2af960f0bcbba1616/boltons-26.2.0.tar.gz", hash = "sha256:d39cfd15c1a1c3bd4d705c82252fa9edb8e4f5e8cc039f8e39afac7b1b47e92c", size = 242047, upload-time = "2026-09-07T10:48:17.711Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e9/ba/cea118a16647cc72633c5236f6f11a09ab76b136b1aaccfa0d7004958428/boltons-26.1.0-py3-none-any.whl", hash = "sha256:1d966b165805b83600b31af9f0db672e3b3313d9de438e22708a94ac5f4c93de", size = 196095, upload-time = "2026-07-17T18:38:41.164Z" }, + { url = "https://files.pythonhosted.org/packages/d2/ac/1f8e4f4855e382a67392ca3bba329cb93aba1e3039289c52a86bf337f7a2/boltons-26.2.0-py3-none-any.whl", hash = "sha256:41942cbce440211bbcf2487ccdc356964ad674f95a01068b8a0dd7a1d1fed036", size = 199536, upload-time = "2026-09-07T10:48:16.319Z" }, ] [[package]] name = "botocore" -version = "1.43.56" +version = "1.43.75" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jmespath" }, { name = "python-dateutil" }, { name = "urllib3" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b9/cc/7f84a5d3071fe878380e9f610ab36ca87b8cbbc4aa81ba2727f90e1f3ea3/botocore-1.43.56.tar.gz", hash = "sha256:6c01f85f0ff9863076f4c761e74ee3aa96c5ccc1ad09fc1efd62ef8f2d22bf57", size = 15733117, upload-time = "2026-07-24T19:31:38.125Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/80/5e39eda5dfb66df691d71212799a9f9d35aa9e447511604030447a00e9d6/botocore-1.43.75.tar.gz", hash = "sha256:e8ed6b0f3cd398dfb9e08d7ca3a0b964152166a317a04e89c45ec91003327ffe", size = 15973868, upload-time = "2026-08-19T19:54:12.318Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5c/cd/86fe9e659e9699f62f8dd5ecd8c6725474334b23cab8aa71d82b5f56f1a4/botocore-1.43.56-py3-none-any.whl", hash = "sha256:aafc741f1b10f6fd63253eaf6ea029680c1ff436d87e1b8969d62aefa0c76976", size = 15418773, upload-time = "2026-07-24T19:31:34.758Z" }, + { url = "https://files.pythonhosted.org/packages/94/46/19d3178e70f37fda251f3d9560f29654f09c6eedbe1c8b790adeee84da49/botocore-1.43.75-py3-none-any.whl", hash = "sha256:121abc8b0b529bc4e29a28d1e8b096b20f26708cabe3d5ae4b3446747712aece", size = 15667237, upload-time = "2026-08-19T19:54:08.802Z" }, ] [[package]] @@ -785,16 +785,16 @@ wheels = [ [[package]] name = "cattrs" -version = "26.1.0" +version = "26.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "attrs" }, { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a0/ec/ba18945e7d6e55a58364d9fb2e46049c1c2998b3d805f19b703f14e81057/cattrs-26.1.0.tar.gz", hash = "sha256:fa239e0f0ec0715ba34852ce813986dfed1e12117e209b816ab87401271cdd40", size = 495672, upload-time = "2026-02-18T22:15:19.406Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/b2/42f4524e5479b090040b5fd8bb316dd8c65a079bb6492494ce2079dc91be/cattrs-26.2.0.tar.gz", hash = "sha256:3cf49f69df8326bcf17a3cb3d3d3ec4a856858fe3a7473746c9044c317d3ba55", size = 524993, upload-time = "2026-09-06T20:31:58.055Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/80/56/60547f7801b97c67e97491dc3d9ade9fbccbd0325058fd3dfcb2f5d98d90/cattrs-26.1.0-py3-none-any.whl", hash = "sha256:d1e0804c42639494d469d08d4f26d6b9de9b8ab26b446db7b5f8c2e97f7c3096", size = 73054, upload-time = "2026-02-18T22:15:17.958Z" }, + { url = "https://files.pythonhosted.org/packages/f5/4d/6b8460462012a52075ba97932197f8c141be71b8e5f7e918af08ee73424b/cattrs-26.2.0-py3-none-any.whl", hash = "sha256:c680f17cd1df3a1c038ad1db8d90a9c595568cc54c4e8098e7ceb8d7b9bd826b", size = 74830, upload-time = "2026-09-06T20:31:56.327Z" }, ] [[package]] @@ -1531,11 +1531,11 @@ wheels = [ [[package]] name = "extra-platforms" -version = "13.7.1" +version = "13.9.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ae/7d/507e27b623cbc3a1d81b2a5ee9f1d94cd4151c605986396b41b97f20d804/extra_platforms-13.7.1.tar.gz", hash = "sha256:9c0056a60c89097e531745b3925a717aa4719cd3d8acd48f7edb8f9de7969079", size = 478006, upload-time = "2026-09-03T15:34:43.288Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b5/12/6b1174fdc301af0b920d53dbb8fcc247f8d0d8349ea227801db012221c08/extra_platforms-13.9.0.tar.gz", hash = "sha256:971d373715cdcf5f4e5bdec5cd733b058fb589d7365ba964f654617bc35fcedc", size = 481559, upload-time = "2026-09-07T19:02:53.715Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/78/95/4cb5e2e3c3c28ffeeeda086129047eabb7d5aac992db7cffb07e52c98a27/extra_platforms-13.7.1-py3-none-any.whl", hash = "sha256:e5255107fa18eb2fe63e88c267c0ef361cb4ff051182431cc35bc2f7b9d19962", size = 103240, upload-time = "2026-09-03T15:34:41.81Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d8/712f0b3717c37398d74ba60740484e93ddcdc48b1d7b3d6043e09ca81467/extra_platforms-13.9.0-py3-none-any.whl", hash = "sha256:51f5499104c2c3d4ad5dafee0a0d74a9c4c22f506ee6a53cbf4ac6e982d556ff", size = 103612, upload-time = "2026-09-07T19:02:52.133Z" }, ] [[package]] @@ -3672,7 +3672,7 @@ wheels = [ [[package]] name = "numpy" -version = "2.5.2" +version = "2.5.3" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.15' and sys_platform == 'win32'", @@ -3688,73 +3688,73 @@ resolution-markers = [ "python_full_version == '3.12.*' and sys_platform == 'emscripten'", "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] -sdist = { url = "https://files.pythonhosted.org/packages/9a/80/db0b4559e57ec36362bedbb05530a87fafbcb6067708c946967a41d449e7/numpy-2.5.2.tar.gz", hash = "sha256:d482d171c406ae88c5b19cad3b6a1c4c5209f886ab74bc44c2c865c23f52d860", size = 20773161, upload-time = "2026-08-09T13:48:27.962Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/69/72/dccb0aaf40972777283303919f613964227266d0c13adebb79ac124f1c3e/numpy-2.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:14e373cfc6387177e8409dac3c7159be8eb05cd77096cd7c950268b86f62831c", size = 16891693, upload-time = "2026-08-09T13:44:51.702Z" }, - { url = "https://files.pythonhosted.org/packages/60/2e/b5aee50a1f74ac815cf8331812cb8251e29024025de462e0c047641c614c/numpy-2.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4bbd96c833ecc8cc069ce518078fc8c60cb9cbfb0fea5b7a803ad65035596d03", size = 11903109, upload-time = "2026-08-09T13:44:55.501Z" }, - { url = "https://files.pythonhosted.org/packages/f3/f4/29e78102a80601cf034d4e9767022cffeca2c3b4c926e1754572ca95593d/numpy-2.5.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:6e8172ddfcf5cf74b811d372b570b83c60bd2de87a6fbfbebdadb4a9bd9c6cbb", size = 5350202, upload-time = "2026-08-09T13:44:58.401Z" }, - { url = "https://files.pythonhosted.org/packages/11/4b/dcd3b7eadaf4035d2c7a4289d232523a6964f602598ef7674e4bd7291f93/numpy-2.5.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:65f188481f1669e26f62b701e8205d19e460fa4a9b52a1414ba382330e4a3414", size = 6687736, upload-time = "2026-08-09T13:45:00.813Z" }, - { url = "https://files.pythonhosted.org/packages/e5/21/4947e0e9d6c9fc2e2ff15b8949049ee44f63adb9cacc729ab8793f97e712/numpy-2.5.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee9c4eeb8454b3660a8b53493563c3e121c2fc94fbd72b848ef814ed7b676a9", size = 15612696, upload-time = "2026-08-09T13:45:04.151Z" }, - { url = "https://files.pythonhosted.org/packages/3a/5f/62d28cf019460c7f1394105b4d49d9911a9c444cb77ab0bd95a204c5a6de/numpy-2.5.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3cdec01fa790a186d430433fdd4d4ffb70eed6f0eeb4bf05c8dbe2dce0a9bcb8", size = 16722264, upload-time = "2026-08-09T13:45:07.714Z" }, - { url = "https://files.pythonhosted.org/packages/14/25/3f0be4c1b9fdf5dd5e708a6806978564d7c46a055c000496309ff2a2f8af/numpy-2.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7999d4ddb0c4025018373fd787510d46e04c769467af22869707b3c1cfd459ab", size = 16974396, upload-time = "2026-08-09T13:45:11.316Z" }, - { url = "https://files.pythonhosted.org/packages/22/72/6262cbdeeb45da9d971e40715f579d791603ba8ec0b5e2db1ac55454421d/numpy-2.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c1f017dc0875c9209d219f97feceb7d54c2661bb243deb4114478e1295808af7", size = 18476044, upload-time = "2026-08-09T13:45:14.869Z" }, - { url = "https://files.pythonhosted.org/packages/36/33/29208b8b075bde62d26a81d14b358c42b0f69b6cabd98d4ff97f37f22b05/numpy-2.5.2-cp312-cp312-win32.whl", hash = "sha256:d6a48072864e3324e194a8fbb3c657bcc5b5c869dbc64c9537b1d5c862572c0a", size = 6072817, upload-time = "2026-08-09T13:45:17.867Z" }, - { url = "https://files.pythonhosted.org/packages/7f/b9/87fea2769fe1c47c1b5b01d8310772c9d1a85d485de7cf386ef7a3332b02/numpy-2.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:28ac63476ec7651484215ee7fa15a1f78b57c14621f01e392afe17b9a1390ce4", size = 12464674, upload-time = "2026-08-09T13:45:20.734Z" }, - { url = "https://files.pythonhosted.org/packages/14/52/032b97e00461ab0809bbe4c588b035620e5a14b8cdee47ecddefc7b17d33/numpy-2.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:27650bb0e7140fa3d37b9923b4803645e0b125d190f326eecfd3f4dad8e8ade1", size = 10397131, upload-time = "2026-08-09T13:45:23.73Z" }, - { url = "https://files.pythonhosted.org/packages/f5/d2/6b24738a0ef4557d189b150046cd07823c50e4273e8aebd651222e24306f/numpy-2.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8e4cb9a754c8a0c62eaa88273a5fba3391f4a610d1dee893c0755da31c083f15", size = 16886595, upload-time = "2026-08-09T13:45:27.323Z" }, - { url = "https://files.pythonhosted.org/packages/65/60/f2d208d366f263f39c6e69ed309290717aab41078b6d04c9be2a84fa2a07/numpy-2.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:52c808f96484f5571a5cc863775ce50247c17dfb3b0361f8ed6b4b0456f80080", size = 11896845, upload-time = "2026-08-09T13:45:31.638Z" }, - { url = "https://files.pythonhosted.org/packages/3c/79/81e0bf24f4d020a2b1d5cd297a9f60c3f24eeb116f9bba5870443f7b6a4a/numpy-2.5.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:29d81e97f668489cba8ebfd796b9bdd453525d35dd9e162e2daec94bf3fc7740", size = 5343880, upload-time = "2026-08-09T13:45:34.373Z" }, - { url = "https://files.pythonhosted.org/packages/ba/cc/e3141cf06d1a8a2c7e107543fe1269c1d1af760d4d683c0794a4ee1127c2/numpy-2.5.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afb3f0632d6b2e3ba04dbce8d1e48d321b369138b73830b5ca371a0e8d479d56", size = 6682264, upload-time = "2026-08-09T13:45:36.7Z" }, - { url = "https://files.pythonhosted.org/packages/29/f1/2a64a307d92c5d98f5255a4014eb43bb6103ee477087b61ecae44a3aa9b9/numpy-2.5.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0aadf13b60048d501e05fa699efaf7734e2494f3498a4c2a5521d822640324f3", size = 15609566, upload-time = "2026-08-09T13:45:39.518Z" }, - { url = "https://files.pythonhosted.org/packages/7b/44/59a1eb68e773c4098d107ef34a0dbdeca501d72ffcfbff9a7707343921ce/numpy-2.5.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29b86ff8a6cc556b47ec6b64b194815cc80e6bf5eedcc6cddfd65318cb0b4eee", size = 16709995, upload-time = "2026-08-09T13:45:43.661Z" }, - { url = "https://files.pythonhosted.org/packages/8a/4c/3e54d4ddbc359a1295f8b633e8106bcd4d7d4a206e82df051bdfb3058755/numpy-2.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6950c4b7dd562453090548ba7f5da7e59f57f85663f15d5dcc60e249192f7e59", size = 16972511, upload-time = "2026-08-09T13:45:47.094Z" }, - { url = "https://files.pythonhosted.org/packages/f2/9f/02e371638ebf19b66d46231e4be52999e87f32d1961b113bc45656608b22/numpy-2.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b9727f472d2f3888053b8a75ab0cb94745a9de224bb5846dbadc0092101bc71d", size = 18465609, upload-time = "2026-08-09T13:45:50.808Z" }, - { url = "https://files.pythonhosted.org/packages/eb/ae/ad6645abc7a3510fe48e8ea1ab4598166f500057ef4ebf38bfad4f1577de/numpy-2.5.2-cp313-cp313-win32.whl", hash = "sha256:4f9744f9fbdcea0bc552e8f19e1f141f811a3f9bc2be2cc6e86d982cab23e3f4", size = 6070204, upload-time = "2026-08-09T13:45:54.111Z" }, - { url = "https://files.pythonhosted.org/packages/15/20/f3489f86d81ea460b2bcdceaed094142ca6579f6be0ec527b781d39afe68/numpy-2.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:85aaccb24182c25df891ad0ec333585967e115269d5f1b17f2c9ae005bc96657", size = 12460532, upload-time = "2026-08-09T13:45:57.167Z" }, - { url = "https://files.pythonhosted.org/packages/d5/21/35b31dde1b283b79de828b80f876afd8c94e28fe1e9c375f89e261cc4c0d/numpy-2.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:bd68ece1553d2023c09a4226d9e41c586ad2d20594d1a456186c33513d2cb3f2", size = 10396725, upload-time = "2026-08-09T13:46:00.478Z" }, - { url = "https://files.pythonhosted.org/packages/ac/f8/c3b222bf075b50afd8e949a07a15c4b312a4a84bd8102a332bcd953cbbb4/numpy-2.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d787cf769c3baeb5f6235e778edb52c08dfa923789b5958f28e6450f96107cb1", size = 16885180, upload-time = "2026-08-09T13:46:03.939Z" }, - { url = "https://files.pythonhosted.org/packages/17/e1/2c1d4b1987795a92b5bbf7c24fe249ab96aa2573ab0d7604802c189d7b86/numpy-2.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:24b9dc2e3d84aa58523798805194e23e736f3f6ce2d1a5b92583ae734e6dbda8", size = 11907878, upload-time = "2026-08-09T13:46:07.045Z" }, - { url = "https://files.pythonhosted.org/packages/b9/ee/d08226fc858044355983a6e5b94f08ff6f3969e0a2b160a4a89f0ddb3445/numpy-2.5.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:9e9413326d726c2545bfa65d2c0876871e8d8386e77f992c1d426e180bbd4323", size = 5354922, upload-time = "2026-08-09T13:46:10.04Z" }, - { url = "https://files.pythonhosted.org/packages/94/f0/6d3d933056440ebbc5e6bad92065fc6c26a48a84a36b1208580e94eea76c/numpy-2.5.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:60e902ac295855348a5ca2ea4c89108989a9f5fddfad3dfc0a8f36b10358567e", size = 6679168, upload-time = "2026-08-09T13:46:12.275Z" }, - { url = "https://files.pythonhosted.org/packages/c4/3b/ecd49dd90033cceb2704d88ca905d4d7d89b0e8c739608754ffd325fa820/numpy-2.5.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50e500dc868e9313530ce12ba470fe50ff3afe3d62993ed6eff652dacd555b65", size = 15624501, upload-time = "2026-08-09T13:46:15.322Z" }, - { url = "https://files.pythonhosted.org/packages/c7/99/461bd36dbdfac6c1c53efa370bd55a83227542d0d118f1677dbf1a3dacd5/numpy-2.5.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318b9a4c845dbea06708a29c84ee429cc3065048db34cdb799047643492050ee", size = 16713701, upload-time = "2026-08-09T13:46:18.949Z" }, - { url = "https://files.pythonhosted.org/packages/f9/9c/2b251df9e8a5d647b62b0cbc1b90a91850c1cf4859ecb532fd0b4eacff6c/numpy-2.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:34c319e2963be042673fb46570501b2f06c41924e17e3563d58646b4380dfb68", size = 16986065, upload-time = "2026-08-09T13:46:23.006Z" }, - { url = "https://files.pythonhosted.org/packages/8f/25/20de43f53ff1390534a124475055a19f01fe10c920a0fd11b8e18d6d6052/numpy-2.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f06571a052127dc1b4e8b83029b4d1b20daa2b64a31cdd181fc6bc774e9000eb", size = 18470031, upload-time = "2026-08-09T13:46:27.102Z" }, - { url = "https://files.pythonhosted.org/packages/56/5e/0c577ca308d6da5eb79b546ba10bbe5b60148192194e2da060913b1de4f1/numpy-2.5.2-cp314-cp314-win32.whl", hash = "sha256:2cc779226e476d1e1f08c74068c419e60f41a9e0e069c92f6671d31d5c985e98", size = 6121028, upload-time = "2026-08-09T13:46:30.046Z" }, - { url = "https://files.pythonhosted.org/packages/15/5c/7bcbd5b11f94199073320410cddcbb80cee62415bfeb540874b265c2d922/numpy-2.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:7587f53dfbd5edc0f7b87c6217b4c6d2d1f2ef9c3da70bc1315e7db5f8d7ec9d", size = 12597627, upload-time = "2026-08-09T13:46:32.886Z" }, - { url = "https://files.pythonhosted.org/packages/87/bc/4d0b06fba0da90ccc75af62823cb9dcedb6c9ea0cffa058cb2c9ee773a77/numpy-2.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:3e4c367352d3747784248a227fbec218e193b56f7e6692e3b64fc805478ecfdf", size = 10680414, upload-time = "2026-08-09T13:46:36.036Z" }, - { url = "https://files.pythonhosted.org/packages/cd/17/f429aac9dc08833a0d0f188eba38c532a751b1a1f2ca6018a37b455cb321/numpy-2.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b879fb674276e331513fb136b78dbc6bd3c848309e0d841cfd63be3896c4cfc1", size = 12026967, upload-time = "2026-08-09T13:46:39.084Z" }, - { url = "https://files.pythonhosted.org/packages/ca/9f/d0849de96a2a4ceaa16662f18ee13eaa9c0aa418269fdc8c4857c56b11da/numpy-2.5.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:fd0d703772bba096843785bd38371e31bb4a0c1151497ad5739d182114a73f7f", size = 5473874, upload-time = "2026-08-09T13:46:42.075Z" }, - { url = "https://files.pythonhosted.org/packages/89/3c/8df216d4a4a5422a3de045301cf7df8ea47286d76f5cb7160b0128ac26b7/numpy-2.5.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:3a2f061cebd9e3d23bdcfaaded5e2293a4c6a5b60fa42df85d410a725ce621bf", size = 6789276, upload-time = "2026-08-09T13:46:44.387Z" }, - { url = "https://files.pythonhosted.org/packages/e6/3a/20d7e9891c4ddfadd6ff8d95bf4b29f353d8e1770553de2099880551dfb9/numpy-2.5.2-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6df895598c0edcb41030126c89e0f353b07d93238116143b7405e937359736c4", size = 15659154, upload-time = "2026-08-09T13:46:47.538Z" }, - { url = "https://files.pythonhosted.org/packages/aa/d6/f3aa3d2688bf501b858835c6bd087ae9b51a56ae6fca8e2b0990abd177af/numpy-2.5.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ab3d4a901f844ea836c3e80bf463c6a27d7f3c14e8e292fcf28d348b25b9bce", size = 16748909, upload-time = "2026-08-09T13:46:51.442Z" }, - { url = "https://files.pythonhosted.org/packages/7d/8f/1c5cae8d2baf86ab802ae97a00be55bc7e21ebc11b12bbc33376c5f05342/numpy-2.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:cebc2d6dbb605a7703d59751dea4bd6b0ab127a5a4338a6f432df1936fef8b26", size = 17027685, upload-time = "2026-08-09T13:46:55.095Z" }, - { url = "https://files.pythonhosted.org/packages/5c/27/71d3467404aedc1c24ce79610f91b52b0b0f466c43a701aa56fc75c145ab/numpy-2.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eaca7ff36f0f52e2111ec71f169d8fd3e889e7ddc0d2592e0d703fd8d3ce8fac", size = 18501181, upload-time = "2026-08-09T13:46:59.09Z" }, - { url = "https://files.pythonhosted.org/packages/14/2f/42921d27c40aea7e077f4a423ae509fd9220b028cd787bafefd8ab2b3a5f/numpy-2.5.2-cp314-cp314t-win32.whl", hash = "sha256:ddf47472af2e4280d79bac82304f5e80150211f1b9e614b760061d5fdfbb6eba", size = 6271085, upload-time = "2026-08-09T13:47:01.903Z" }, - { url = "https://files.pythonhosted.org/packages/75/e6/bad5f5d56de9b1971bac959963dda276d35c40f1854475005434bbe08692/numpy-2.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:44ef9675d908e65f9953063837c3277730f3f4437615a4cdab67b366cabaf884", size = 12787971, upload-time = "2026-08-09T13:47:04.963Z" }, - { url = "https://files.pythonhosted.org/packages/df/05/f608795cb34391acd67e38d94a3c36abd8d8576293a3a80727d7595c372c/numpy-2.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:eaa088384c46f519dacb93b7ec483a6d6b19a4a2085ae4f25ab9b1c43d387d1e", size = 10750306, upload-time = "2026-08-09T13:47:07.976Z" }, - { url = "https://files.pythonhosted.org/packages/33/c6/28de0191c5f82b7d42a0a51390ba98587048aa93a39fafb05bdbe6e8d00c/numpy-2.5.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:078f9b027b478c9379b9677babbf0f8b8f1ecfada27636d7b9a93990c638739f", size = 16885274, upload-time = "2026-08-09T13:47:11.439Z" }, - { url = "https://files.pythonhosted.org/packages/dd/d1/973ca116000d244897e468ea1aff30b589e5022e3c8744b71706fe33bd57/numpy-2.5.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:50a68f4bacd8a2b33d8da3d2269d0d78500f86ea582e4786dc10f5ef2c2c6842", size = 11907846, upload-time = "2026-08-09T13:47:15.128Z" }, - { url = "https://files.pythonhosted.org/packages/78/d9/8c4b3937ef204cb2fd88d389ccd0f265a2ffb11f35a01d2064cf46714bd6/numpy-2.5.2-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:e79aba74ffaf5f78a050d777c184cddf8fdffabab38acf5f3ef1fecbc17895d6", size = 5354892, upload-time = "2026-08-09T13:47:18.07Z" }, - { url = "https://files.pythonhosted.org/packages/74/9b/b6ee65ea2999fdb7023935e108e6fb776ee4082aa15f159acfa857e578c8/numpy-2.5.2-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:9a0731745a72a184490a582fb4af2533512bd071ace67785b5fdffc0ae58dce8", size = 6679309, upload-time = "2026-08-09T13:47:20.456Z" }, - { url = "https://files.pythonhosted.org/packages/43/f3/acb18d8b137a393c8e7803a8c994c9e64bde3930692a69d826993113a159/numpy-2.5.2-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ec954036759bcee3aa484f8603bd9c14f3e776293b85578b8734c2d72777c69", size = 15625850, upload-time = "2026-08-09T13:47:24.365Z" }, - { url = "https://files.pythonhosted.org/packages/a9/bf/a8e9bb0db815a0e265b5744ebedd3af0bd5faad8604e5b50a1cd012f3c91/numpy-2.5.2-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc649493697006bc90614a5f0bbc8cb3cb1866715c474e473694968d7e6b99ab", size = 16713664, upload-time = "2026-08-09T13:47:27.965Z" }, - { url = "https://files.pythonhosted.org/packages/0c/c3/6e913736b3dd6582344af32418b5fb9dab34282e8a8174ae1d54ceb0fc13/numpy-2.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:cf7de32f486e4ac9e2d93b810f9e9ac72a728dd46a32a0bb403222f27f653514", size = 16986749, upload-time = "2026-08-09T13:47:31.541Z" }, - { url = "https://files.pythonhosted.org/packages/80/09/7d3b23eff5c7428ef6c01e6f7052bb60d504c4d33e317b36b8959c24ad97/numpy-2.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:2ffa7bacab3e2ee1b19ed31766bb60bb380b68c23f051e199c5cc598afd68710", size = 18470495, upload-time = "2026-08-09T13:47:35.364Z" }, - { url = "https://files.pythonhosted.org/packages/a5/a4/68a321d825374f6eb677ffe8ef8c6b9a328304e6fd2e39d9530822776607/numpy-2.5.2-cp315-cp315-win32.whl", hash = "sha256:6b588cc8f902d6bff201c19fd00c43ab8545671e3554d014e12e14139e5e8617", size = 6120696, upload-time = "2026-08-09T13:47:38.561Z" }, - { url = "https://files.pythonhosted.org/packages/c8/23/deafbb1700f79fae9cd1e91220f133d124cc267de1b584da3fbf6db2f6cd/numpy-2.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:07d4e89f3a9ab0a9ba24264ccdb642b3dd951b2281e8883a5481a4aa79cc31a7", size = 12597324, upload-time = "2026-08-09T13:47:41.401Z" }, - { url = "https://files.pythonhosted.org/packages/33/cd/3272ba105e3bbbdaeb11357eda31e7a6825ffe159e8171665660299a948f/numpy-2.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:a610dc7e3c52edd39c2bc2375ff9c3fd59cb3ad00e4472d36f83bc1457145788", size = 10680466, upload-time = "2026-08-09T13:47:44.873Z" }, - { url = "https://files.pythonhosted.org/packages/0e/0e/58370637b1bb70a5c9ce2b43f4b521ccb224e36ccb76a6596b17ae4b447c/numpy-2.5.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:40f4d451aed46a8046a1aae41c4e55fb3612273df9c502480135e1501576a34b", size = 16993947, upload-time = "2026-08-09T13:47:48.97Z" }, - { url = "https://files.pythonhosted.org/packages/10/93/2abcb807712b289d6d60fe4cf30532f98974a8396d885650f3ba5a13026e/numpy-2.5.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:c081cbe16ba1ab53078e5ff29013621e33c509eedab055775d956427712c236e", size = 12025331, upload-time = "2026-08-09T13:47:52.646Z" }, - { url = "https://files.pythonhosted.org/packages/8b/3a/2898e003a5fbaf87e76c039b4ee1f5eb390471b4ffe74887c1f34c4e791e/numpy-2.5.2-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:0090ccdd57ec2703e9b49d0bf554767370581c1dd0a6b2bb2b2d9def317d042a", size = 5472336, upload-time = "2026-08-09T13:47:55.403Z" }, - { url = "https://files.pythonhosted.org/packages/61/a5/23f69d07c544597b29758b31b55c27dc9d541012a2c1496189fef702aec2/numpy-2.5.2-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:6a9bb119fb8dd21ba30b3f0e555b7e2b081bd9883af21ec9c1c633d161cda3a8", size = 6788387, upload-time = "2026-08-09T13:47:58.192Z" }, - { url = "https://files.pythonhosted.org/packages/15/ea/c0dbdbcf22f43782510a3e492dd3da73c6112b69cac8929d16d127536fc4/numpy-2.5.2-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a839318485284a6fb31be4f8f2c91c8f2cb22f4543c4a8903f12b0671ffe07cc", size = 15667096, upload-time = "2026-08-09T13:48:01.562Z" }, - { url = "https://files.pythonhosted.org/packages/fc/5e/29c73c31748cdb0f7566642125ba17fd5b56780cddf891b085dab27e4466/numpy-2.5.2-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba0a474801b8dc67b66bf465548abc90e82b44d2611b5770f33008dcabffe8ec", size = 16751730, upload-time = "2026-08-09T13:48:05.706Z" }, - { url = "https://files.pythonhosted.org/packages/47/95/02501e8454796bb58dadf7a99d3181e0b464bf264e1003039572f9779fac/numpy-2.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:0a4035ae1129ff8777f08bfbd44f1e5d8e9c049ce0c2dd78fc0d92c13e7251c0", size = 17038686, upload-time = "2026-08-09T13:48:09.627Z" }, - { url = "https://files.pythonhosted.org/packages/0e/b5/53a681d91b5c82687067d8ea5035e02d917b5509d6f334cb06484a954714/numpy-2.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:77843ca236b777e67f8d6b3660ea116e499612703a0ecd7093f316201eb9d8e2", size = 18507727, upload-time = "2026-08-09T13:48:13.744Z" }, - { url = "https://files.pythonhosted.org/packages/42/06/6e11443f7b64ee376c860506091103bf68f92d2cab9e8d96d4501babf07c/numpy-2.5.2-cp315-cp315t-win32.whl", hash = "sha256:7354826bc6f8f69402e9b7fe28d15fcd34feebd74f856f111585c5b0c9fb0251", size = 6269775, upload-time = "2026-08-09T13:48:17.543Z" }, - { url = "https://files.pythonhosted.org/packages/f1/18/195d6b86cd72dbbc501edfa778005fa6b87afd34c153e46028cd3a0938f4/numpy-2.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:e5651f3f87add730ee6608d915009e19c911fba0cb000c7e3ea994b7d768eb12", size = 12782559, upload-time = "2026-08-09T13:48:21.023Z" }, - { url = "https://files.pythonhosted.org/packages/b4/07/458c344f0f0c178f4481dad5cca790626ffe4c34eabf9467069d06ee4999/numpy-2.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:5f8e00be2ec6f45f4e8a41a527f68d44a7d96fee92a650e4d8b1326f77f61e6e", size = 10748103, upload-time = "2026-08-09T13:48:24.21Z" }, +sdist = { url = "https://files.pythonhosted.org/packages/13/01/11703282db468b85f6f7b8c7f22d058de5970d5c7e60a3a8aaa313c3de36/numpy-2.5.3.tar.gz", hash = "sha256:df2d5874ff183595a4ba404edd04f6bd9b5505c1d7708573f6a6c17489a67563", size = 20791231, upload-time = "2026-09-06T16:27:47.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d6/50/8fdbb16af64895706a45f06a4068e29db732ec180f3c1375f14123359138/numpy-2.5.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cb189f09db39283b26bfd061ec16189e14f71c6755207f72a0f7540867afe5b9", size = 16994982, upload-time = "2026-09-06T16:24:29.244Z" }, + { url = "https://files.pythonhosted.org/packages/60/39/789131c1188c078dcb3a1692e72e1e050c68b88ffe72c9ccaac9bcd7a9cd/numpy-2.5.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f59a878c33d6b88122d80d239bb3b845d58708750b0cb06a09aebb9b18ec696c", size = 12009327, upload-time = "2026-09-06T16:24:32.491Z" }, + { url = "https://files.pythonhosted.org/packages/9c/59/a312e95696e5f601914dd8b6dd844692ba61670807417e24b68e337b5c70/numpy-2.5.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a72f874bc9e10e4b8f80426fb49716d5141f64442a0c8418065093ec8017fbb0", size = 5445405, upload-time = "2026-09-06T16:24:35.071Z" }, + { url = "https://files.pythonhosted.org/packages/30/d0/5623a1707ed4fe16e3909fe3cf5ee3da004ae677ad23d83bbf3adf1a6faf/numpy-2.5.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:fc36dc566135b5eceec4cf89758fcb719266a019ef07dae1754ae7c9f617ef3e", size = 6783213, upload-time = "2026-09-06T16:24:37.253Z" }, + { url = "https://files.pythonhosted.org/packages/f1/32/84146fc020ad3c25f805f70ab60da46fe3c540a21369754a7e4369754b6f/numpy-2.5.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76c2c1e6bfa5c84adc6434dfbf013aa92096a7985221762c8f11fedfd20fff58", size = 15687872, upload-time = "2026-09-06T16:24:39.751Z" }, + { url = "https://files.pythonhosted.org/packages/65/af/aa78d1a88805456e212b65461354cd943197fb9acecc4c90fd12295123a3/numpy-2.5.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7e18c623bb5c95acb3b3328861272816ba199fb531921c5d6d0b675f1fde9e3", size = 16717410, upload-time = "2026-09-06T16:24:42.745Z" }, + { url = "https://files.pythonhosted.org/packages/3b/24/faa79d865e69a97ba17473b23a1b74094b2259c03e820c70297293b9ea49/numpy-2.5.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4f8929ee6c96bfbd7b4ed2032e0c03af86fe1826740ab61ddabf9072d06e57ff", size = 17040975, upload-time = "2026-09-06T16:24:45.961Z" }, + { url = "https://files.pythonhosted.org/packages/62/4a/8877e629445a7176297dffcaf9c485faa96a95d81728a62521ad55bd4c0f/numpy-2.5.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b5d93cf48f687479941d12b69c873ad2cc76bbd487f0091c2200636497f34034", size = 18476479, upload-time = "2026-09-06T16:24:49.35Z" }, + { url = "https://files.pythonhosted.org/packages/c8/db/35e1c2d38b04cbd5b731f9d71495e055e813197669d22b612f11748d2ff9/numpy-2.5.3-cp312-cp312-win32.whl", hash = "sha256:bf63afbe037eb5d2fe87fbcc7778e61da53ebaf21d938a4515aa73b62532a5d4", size = 6133378, upload-time = "2026-09-06T16:24:51.915Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a1/accf6d4f0c80c5d9ba9735d6b1550e444180599f34dec69ca01360f717ad/numpy-2.5.3-cp312-cp312-win_amd64.whl", hash = "sha256:0a59a421a32580a009e8a1751345bf829631b990dc1794b80514ab722b435def", size = 12567828, upload-time = "2026-09-06T16:24:54.255Z" }, + { url = "https://files.pythonhosted.org/packages/22/43/1764aff32e4652526ae2f71fa8b3efd8d25c8a3d6926914454e47138ed1e/numpy-2.5.3-cp312-cp312-win_arm64.whl", hash = "sha256:ccb32e0525d29e8b0572eb84c9a57af0e7a4e615726927506f55063c62414034", size = 10485432, upload-time = "2026-09-06T16:24:57.278Z" }, + { url = "https://files.pythonhosted.org/packages/79/e5/8fb89cd46d14e35699d13bf943a5f5f441ecee8667120a1f6105ab89e349/numpy-2.5.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:66a78fe4556c60aceda5916f9eacd638b18e9e681016ec302dcb4682d6d4d034", size = 16991061, upload-time = "2026-09-06T16:25:00.411Z" }, + { url = "https://files.pythonhosted.org/packages/2f/06/9dc9e48b5e5e941c8b10350c5ff2d721da42a20517d911d15544246775ff/numpy-2.5.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92f30e89b8ee0ecf363033576c422b2f58fed6a80bed0aa48dff6d14c654663e", size = 12003676, upload-time = "2026-09-06T16:25:03.475Z" }, + { url = "https://files.pythonhosted.org/packages/ab/2a/98282aa5b8f58b1157d440bb6282eed47e3632a5de53a714fbab17e659fe/numpy-2.5.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f9a2353b37a1a9e78fd82b27ad7e2a32a2d036604d18f02b05e3136c62ca3b09", size = 5439695, upload-time = "2026-09-06T16:25:05.978Z" }, + { url = "https://files.pythonhosted.org/packages/a1/f9/b6533d777be9d6ffd29dc1be0867e563e6e8cc9a220ff1b716adc317f060/numpy-2.5.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:ccbc4665079665c3cf3bab4db9f6b095370cd6437d66be549b6c2a1fd19e1958", size = 6779395, upload-time = "2026-09-06T16:25:08.599Z" }, + { url = "https://files.pythonhosted.org/packages/73/85/735720d04ec197c5dcfacdfc9922667c7f1f5f496a279b7ba4d7c74c4cc7/numpy-2.5.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c76d5dde9f445058f83d0c02af00557a4db91de9a9a57c0df87d1535001d654b", size = 15681750, upload-time = "2026-09-06T16:25:11.173Z" }, + { url = "https://files.pythonhosted.org/packages/3a/1b/3b16a9bc514a440a7a0883684111dcb1ef1aee960af2ca95da8fc775f124/numpy-2.5.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5fa86b80fd24bcd1aff83ad23be44ea323de3f787be8f8b15d4a65621e25321", size = 16708577, upload-time = "2026-09-06T16:25:14.171Z" }, + { url = "https://files.pythonhosted.org/packages/69/c4/386f397831b07328b639c96c5b62719346cf4baf07c68d927239752b1534/numpy-2.5.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd4cb9ad3c7889b9b3fe0a9a9fb5d2ed26f9879bff2608d9f01aed147a20d231", size = 17042047, upload-time = "2026-09-06T16:25:17.582Z" }, + { url = "https://files.pythonhosted.org/packages/5f/3e/a700ecbf36e85ae8328fd3b0e12eeddc22ed6358a64cb2bd913e0d195d65/numpy-2.5.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1302b90c0e52281681b2975adfe8a860cb7b12216a27b4b0b4207c44bf7bccf0", size = 18465724, upload-time = "2026-09-06T16:25:20.949Z" }, + { url = "https://files.pythonhosted.org/packages/41/ee/38e785e88a4045f6ad1d1f2808dcdfafdca48c760260c0587bf171e29fc9/numpy-2.5.3-cp313-cp313-win32.whl", hash = "sha256:1c80eabb4035ecf4ca9cd49cde8a9fdd69a729e63e6474887d1523ade7aa277f", size = 6129003, upload-time = "2026-09-06T16:25:23.664Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ec/100f2b1794ede74a9b3d7ec6b9736927f56713414c1dfe19ab6c383494bf/numpy-2.5.3-cp313-cp313-win_amd64.whl", hash = "sha256:71cad2b2a7451ab79d8f5e71b453485b6775963d5cf794179144a7463fe6e8ec", size = 12560965, upload-time = "2026-09-06T16:25:26.602Z" }, + { url = "https://files.pythonhosted.org/packages/80/b1/7dc825ca94c12acebbce4c37caa5e198695eb31424bc579679f32b1bb49d/numpy-2.5.3-cp313-cp313-win_arm64.whl", hash = "sha256:8e4dd766076855b5ff7ea52fa5f07ce26286726e0f8bff446b7739d02e6ea204", size = 10482343, upload-time = "2026-09-06T16:25:29.772Z" }, + { url = "https://files.pythonhosted.org/packages/70/78/cf416f15dc29375a229d9dfebf8db6e313f291580b39fa1a568b6052bb07/numpy-2.5.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:350ba9783ce969cf9f7ce6e6a9a58e1a6e2a19ca025b7ee448c4db727706212a", size = 16998686, upload-time = "2026-09-06T16:25:33.171Z" }, + { url = "https://files.pythonhosted.org/packages/9e/59/abcc2d8def4fd60eec7d87f92d27c13448ffd9ab14339bcc63a0d7a2fdea/numpy-2.5.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:012e66aca395d795496446e52aeeb5866312a5d4d3f27da270e5a0b43f70dc5c", size = 12013862, upload-time = "2026-09-06T16:25:36.748Z" }, + { url = "https://files.pythonhosted.org/packages/94/75/4640d2d6e4b64a049e48425a82728a41ef4adb61332d2cba68055774878b/numpy-2.5.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:adc1ada2662f8a5f960b8a10d9986897e7499ef07e06d4cfe7197f8cce923c07", size = 5449793, upload-time = "2026-09-06T16:25:39.476Z" }, + { url = "https://files.pythonhosted.org/packages/96/cd/625b57ae33d4ca560f32cc0b47b4a5922146d9beb998ddf773900d440a73/numpy-2.5.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:54a115e5a73b8fc44f0cebef486365a1894b5c9760685d4558b72b7c3eb846e0", size = 6785176, upload-time = "2026-09-06T16:25:42.069Z" }, + { url = "https://files.pythonhosted.org/packages/9c/72/12918652e7912ef9751e8694c88820fcd1908e0618cb23f5f3caa6004b7b/numpy-2.5.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be5a8381859b6da607c84f4f7d6847725f1cf1853ef8a2c9e115b7d58bef47dc", size = 15703377, upload-time = "2026-09-06T16:25:45.135Z" }, + { url = "https://files.pythonhosted.org/packages/45/8f/9beacf79ca7c650688ad0baa80931adb988fe6e6e5d5903c23cc3dbd70eb/numpy-2.5.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b0521d0f4aebb6e06189451025fa17a913287b13c03d5fe05c017333b654ea5b", size = 16711928, upload-time = "2026-09-06T16:25:48.461Z" }, + { url = "https://files.pythonhosted.org/packages/09/8d/41d0a56e1ac4c87495c897a211b1368691b7237aadabec8b3b8f3a74d48f/numpy-2.5.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9deb49575e5b0b94ed72c8a64ec4d033381adc27e9060ae842971f697ba96104", size = 17059507, upload-time = "2026-09-06T16:25:51.873Z" }, + { url = "https://files.pythonhosted.org/packages/08/1e/0dfbc5cc251d54e2af790f254d24ec38637fa97ec7d5d11de7ffed787098/numpy-2.5.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b00eefbcf0f292945c4b4dec2ae845389ef5bcdcd596e6e4328051db5b5ba694", size = 18471002, upload-time = "2026-09-06T16:25:55.233Z" }, + { url = "https://files.pythonhosted.org/packages/b5/2c/dfa40f6991f8185c8c30ffd023dfcbb11888e823cfab9557b920f3bb7bed/numpy-2.5.3-cp314-cp314-win32.whl", hash = "sha256:c2381f82999704f818e2c987a865050e285ec3621262c66d40f5a96c8f899f8e", size = 6180485, upload-time = "2026-09-06T16:25:58.157Z" }, + { url = "https://files.pythonhosted.org/packages/a4/73/d2c08231e4fde7e415501fd02c715d96e98599b2d8384445933944152984/numpy-2.5.3-cp314-cp314-win_amd64.whl", hash = "sha256:2c25dfa72943e4336ddb6b0ee4277b47a0c85bede0807530ec68103bf58e2c10", size = 12698179, upload-time = "2026-09-06T16:26:00.789Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e9/dcdcc9b95cf5f49815055573aee1b11cfbf5299f38a180e437ded050810f/numpy-2.5.3-cp314-cp314-win_arm64.whl", hash = "sha256:15aa985ac73a8db02db7663381aa109510449d3819d37206caed27b33a65a8a6", size = 10769383, upload-time = "2026-09-06T16:26:04.011Z" }, + { url = "https://files.pythonhosted.org/packages/49/c4/af8bc08a7ef4e1529a7c0cf24969accce316b783999802089a581ec99272/numpy-2.5.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ac7bb1c52d445bd4f8f7f97fefe6abc3a084dc4d63df50d79b17fa2b78e89297", size = 12132668, upload-time = "2026-09-06T16:26:07.138Z" }, + { url = "https://files.pythonhosted.org/packages/c5/ae/0f15eb56d4ec5e13c1f7ff04ff407f997d1acbadb45d3e1f2e2645a8f43c/numpy-2.5.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e6ab667ba76450084eb64013762c438ea76d9d29cc676dcd6c2e9892ba37f841", size = 5568580, upload-time = "2026-09-06T16:26:09.828Z" }, + { url = "https://files.pythonhosted.org/packages/23/fb/c72a8f25d4b6e96c354e7ab45ace3b27dc11e5d6a13b6c7d0cd6b08bf112/numpy-2.5.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:f7fabeb6cea87d65f3b926de33d03fb016cfdc29314c90974383b5582ae72891", size = 6882634, upload-time = "2026-09-06T16:26:12.524Z" }, + { url = "https://files.pythonhosted.org/packages/07/a9/968c90ed2ab15060c338e8137f1215b5a60756ae07328e0a60d1c6734df4/numpy-2.5.3-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fb6f8fb9ff0b3a69f52c66ce397b0246583e9f28616231b0e32ca49259a5fa6", size = 15748923, upload-time = "2026-09-06T16:26:15.092Z" }, + { url = "https://files.pythonhosted.org/packages/59/08/9df04103947b95e3b6b1f2ed1a70521f325647a31b82da6a2aae3a485508/numpy-2.5.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93e1f5447e2b1e479d7bd74701e84746b86450cff1fc368b132d195e2b8f8211", size = 16746748, upload-time = "2026-09-06T16:26:18.43Z" }, + { url = "https://files.pythonhosted.org/packages/41/a0/14c8d5fe5b53a334aabb653deb391c0fef49558f491880ea300ed6785224/numpy-2.5.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c00abe94c1a69d75d827dcf1c025b25c8a45d230b3bcd77a9020883a1b047653", size = 17111561, upload-time = "2026-09-06T16:26:22.113Z" }, + { url = "https://files.pythonhosted.org/packages/c4/a6/d7e96e42f01522e154c32489640f16dfc4f6181d165d05fc3bec8c2c4999/numpy-2.5.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:536f963710a4e63934d80ac0dc4f478804a83e9a84b6828018f25d09953ada33", size = 18513945, upload-time = "2026-09-06T16:26:25.401Z" }, + { url = "https://files.pythonhosted.org/packages/25/39/3453afb7119d0449ef11c886874120ff180e2c337760e0e2d88f70f1a945/numpy-2.5.3-cp314-cp314t-win32.whl", hash = "sha256:4c8a6d2ebce6305fd82fbefca827775437147052a976ee7c94b36a0c1b52ac6c", size = 6335421, upload-time = "2026-09-06T16:26:28.175Z" }, + { url = "https://files.pythonhosted.org/packages/99/01/22815d2b19a1a746b1d45205cffebb3fe511a18acb75fba6c88491fc9894/numpy-2.5.3-cp314-cp314t-win_amd64.whl", hash = "sha256:9a37475425b431b4d060f23b4f52cd2f3aef6bc7c654bd760adf0040eec9d435", size = 12896420, upload-time = "2026-09-06T16:26:31.265Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ee/a7cbba67eeaff038dc29ca8b98a88396c8b0cc9c89d4924f4a27a5c9150b/numpy-2.5.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2d8240cb4c16fd831074aa2b2cf9fc54664d826341d61c372245b96a74a49a9a", size = 10857177, upload-time = "2026-09-06T16:26:34.167Z" }, + { url = "https://files.pythonhosted.org/packages/45/56/78194492883ff5eec90423fe56a3a44b154da047d88a6307f629713c584f/numpy-2.5.3-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:a6391fafaba97500887132cd582abc6e19452b1ac775a47caa7b24490e152058", size = 16996531, upload-time = "2026-09-06T16:26:37.287Z" }, + { url = "https://files.pythonhosted.org/packages/11/39/dd55c0af90bbab564b09ae3b0aa60ec5c02b900fa4f1ba23440525c8b32d/numpy-2.5.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:09d5a423c71ad5feb5625844ad58050e35df43871004b52ac9c0ad44a56775be", size = 12012569, upload-time = "2026-09-06T16:26:40.707Z" }, + { url = "https://files.pythonhosted.org/packages/b6/51/04f67d32e4862b281b1cb84ceeaed3421189a84fb6fb51a391cd6d5009f7/numpy-2.5.3-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:f9579f383d1bf9df80081e72760e84960a7fd4f88cf0c9e535a8597c9bb646f5", size = 5448498, upload-time = "2026-09-06T16:26:43.435Z" }, + { url = "https://files.pythonhosted.org/packages/a3/c9/25b4dc0dd1344ec26c7319e84fd4e9809d2b5628f4e12decd618036e5178/numpy-2.5.3-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:86bff898a431c0fb71f7610b75726e75a54d47b37edc9d537f48de63bb3c0b90", size = 6783026, upload-time = "2026-09-06T16:26:46.374Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c7/29285be1e5232a6e7ee3268a33c85843f5a8ee93350c6465cddd66ebbf76/numpy-2.5.3-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f3ed25271581281f2fccb1adcedfcde4c07362eec69189b50baf6f90e3ae159", size = 15697322, upload-time = "2026-09-06T16:26:49.415Z" }, + { url = "https://files.pythonhosted.org/packages/55/49/bbad5335fb4996a16881f853ff3e0ba582f01720e55c89b1c06b8fc42a90/numpy-2.5.3-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ffdc76bfcae6b255dff75202c5e7feaf95b40246bc0a17944facc1fecf9f79ab", size = 16708995, upload-time = "2026-09-06T16:26:53.127Z" }, + { url = "https://files.pythonhosted.org/packages/ef/e9/1df35483760b04a65ea44669f89dc64f30e5aca098b48ceb8b1310b0e0fe/numpy-2.5.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:116f96cadd935c6122e9228d676fe7ede19e741f5c8bb1c3cddbe0c51ccebea2", size = 17052508, upload-time = "2026-09-06T16:26:56.464Z" }, + { url = "https://files.pythonhosted.org/packages/b8/99/66e54da8265cc8be8a7382bf96edce17aaa2837d6f484432025932a3caa5/numpy-2.5.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:09ffa5d903faeaa5c4dd05009cf81c8bab9f2cb37c548b8d39b65b4cfa7c97f7", size = 18468224, upload-time = "2026-09-06T16:26:59.966Z" }, + { url = "https://files.pythonhosted.org/packages/01/bc/b5e90a91c115168d793dfd2ad9c69c438c2fe7a13a437e770bc5b078e732/numpy-2.5.3-cp315-cp315-win32.whl", hash = "sha256:e01c918ac3d48e18a927cf7b14a26a3e29ff2bdf2eacb976da0aecd6a43ed034", size = 6179919, upload-time = "2026-09-06T16:27:03.166Z" }, + { url = "https://files.pythonhosted.org/packages/37/ea/780748fd3985109075514ef8fc64cd25f943e40dde13a6d59141eb268fc8/numpy-2.5.3-cp315-cp315-win_amd64.whl", hash = "sha256:e931e4f499e0dc7ef29d269a8e5b35dd722e5d14be07df6240166ea7c6532fae", size = 12697656, upload-time = "2026-09-06T16:27:06.153Z" }, + { url = "https://files.pythonhosted.org/packages/b3/16/407be69a2a87c8cab64d95975a8977a426a29e138f07e276ec258f0fe4e5/numpy-2.5.3-cp315-cp315-win_arm64.whl", hash = "sha256:26e15e4aecd8617dfbaecb37d223e365d7b39411fba20454be2670a96aa74cb5", size = 10767601, upload-time = "2026-09-06T16:27:09.297Z" }, + { url = "https://files.pythonhosted.org/packages/44/bf/a97ffb01e41d50a32a9177aef942a4d0e389a3daf451d04e5f38ef6afb87/numpy-2.5.3-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:6cef4bb1706dfec49243c05d921eefb4e190d41e2528b30d8035ea1f36b4c24a", size = 17090092, upload-time = "2026-09-06T16:27:12.907Z" }, + { url = "https://files.pythonhosted.org/packages/d1/24/136c02f2c2af9a067a84d0c3aa10c99012c0476fa5066732fa4a4202557d/numpy-2.5.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:d1c89973648c85069c5046ad460f7b8a00218b29a2e42359ac8cc63e9ab94832", size = 12129429, upload-time = "2026-09-06T16:27:16.089Z" }, + { url = "https://files.pythonhosted.org/packages/fe/6c/b47582d6597789bf946d5efbeb6b9e56fd8bcbd5efc6fbf51dbe1ea31eb3/numpy-2.5.3-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:214045a5bf00113a146ab9ee9730c44501af6723cdf1f6830932f7b5ef2e7af0", size = 5565452, upload-time = "2026-09-06T16:27:19.868Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/ef3cc6da73774202d4deae16bb321fd8298a4e0561e3539f8c4be237d916/numpy-2.5.3-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:8617bbfae4486cf99c9f899966699428d19da931d06ca94ad3da986c76e15997", size = 6876736, upload-time = "2026-09-06T16:27:22.232Z" }, + { url = "https://files.pythonhosted.org/packages/9e/24/e3813329498596cb842703dcacac1741612ed9fb9c4e6a3e0c7e2ebbc597/numpy-2.5.3-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:595d020938c84e320bcf40ad71089e108eac0d377cd018e14a8c094f39e98d85", size = 15745777, upload-time = "2026-09-06T16:27:25.181Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9e/4e7a07fd0776dc2210cdacf2010be8665194d094defc10c419d7dea794cc/numpy-2.5.3-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f24021b9f22bc6301c37b196974a92c1c18dccedb6fef3dd252e95f2d6adbe4", size = 16746949, upload-time = "2026-09-06T16:27:28.576Z" }, + { url = "https://files.pythonhosted.org/packages/91/db/01674c0e20335057813a00c2ebd546ed25bff9ed7914f9bced00f8c55d94/numpy-2.5.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:71b39d9f935b6ec0f8753e3e2afb51e3efba6f2e05b68b32a40754d24bcd4a3c", size = 17108994, upload-time = "2026-09-06T16:27:31.946Z" }, + { url = "https://files.pythonhosted.org/packages/45/7a/584c5e71f8d378e57cac0b033891ed65c683ef90573ba4854e8c28203db0/numpy-2.5.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:6b05c171afb3aa07adbd20abc00aea86fe375beb0fdb9ef780ec5b7f63bab1c0", size = 18512266, upload-time = "2026-09-06T16:27:35.196Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d2/4e1014173aa3c55e6a756e0e567290743a6ab33a288460374d7ef6bcd239/numpy-2.5.3-cp315-cp315t-win32.whl", hash = "sha256:f54660b0eb6b0b9f36e7fe1cdfdff472028dd0d14acd9b9b65098efbad059469", size = 6330292, upload-time = "2026-09-06T16:27:38.149Z" }, + { url = "https://files.pythonhosted.org/packages/6c/b0/ff5658a58199b7bcaad87bf260eef6713d9d42cca4e028f935b4fc5fbac6/numpy-2.5.3-cp315-cp315t-win_amd64.whl", hash = "sha256:1aad64d99730d013cfc6debafed22783b4fc5a7f4b8bc744d2d8cf7dcc880551", size = 12884918, upload-time = "2026-09-06T16:27:40.965Z" }, + { url = "https://files.pythonhosted.org/packages/fb/0b/b12a2df5d1b774bd9007a6fdff9381145b6223d37f11afc9c37ab0efd9a1/numpy-2.5.3-cp315-cp315t-win_arm64.whl", hash = "sha256:befa1ae5bd6030b3f512b43ff3fa5290bbed6b84411a44244b14adf835f5b89d", size = 10850807, upload-time = "2026-09-06T16:27:43.868Z" }, ] [[package]] @@ -4121,7 +4121,7 @@ resolution-markers = [ ] dependencies = [ { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, - { name = "numpy", version = "2.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "numpy", version = "2.5.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, { name = "python-dateutil" }, { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" }, ] @@ -4177,7 +4177,7 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, - { name = "numpy", version = "2.5.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "numpy", version = "2.5.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, { name = "types-pytz" }, ] sdist = { url = "https://files.pythonhosted.org/packages/92/5d/be23854a73fda69f1dbdda7bc10fbd6f930bd1fa87aaec389f00c901c1e8/pandas_stubs-2.3.3.260113.tar.gz", hash = "sha256:076e3724bcaa73de78932b012ec64b3010463d377fa63116f4e6850643d93800", size = 116131, upload-time = "2026-01-13T22:30:16.704Z" } @@ -4946,50 +4946,66 @@ crypto = [ [[package]] name = "pymssql" -version = "2.4.0" +version = "2.4.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5d/4b/15f8faa7ffdcf1102637485869d87f1ea6d6a5b148cc7af9ee07d644e1c8/pymssql-2.4.0.tar.gz", hash = "sha256:c74eeb11f154eaec72ba39db3395cec8b522b580a3165584915390d6f7e962b3", size = 204966, upload-time = "2026-09-01T01:11:57.666Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/af/ee/92747df77df3946f00fbb22d30f51ccd4001883ac80ad3a847b8eabb7fd5/pymssql-2.4.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:30039f7f36449fe681b04bda836737beb95608df1ad83ae5e7d3eab66096aeb7", size = 3202924, upload-time = "2026-09-01T01:10:30.69Z" }, - { url = "https://files.pythonhosted.org/packages/47/d0/fd17777e5243e5bf1a46ac2ed5c86b5b0397d760f70bbe5a0f841c2e1fa8/pymssql-2.4.0-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:c6330c9b0b8616767ef734ec669942f9e40242a55451159c7b7e9d8b80f2833b", size = 3008411, upload-time = "2026-09-01T01:10:33.051Z" }, - { url = "https://files.pythonhosted.org/packages/f1/35/b57c31ca10e22a0b54bee736a1791c789c07a52cc03e79aa0a083127d281/pymssql-2.4.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d29cfc54681598408441f750854e6d70f494bad1cb6b4e92ef2d43d51764dc3e", size = 3060810, upload-time = "2026-09-01T01:10:34.693Z" }, - { url = "https://files.pythonhosted.org/packages/5f/32/9c6a1882a27fe7de07afb59b1a2f89845d55056db66d6405004705336db2/pymssql-2.4.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4d9018f5b1341d836fa785ef7ffed636b8c7aedcecdc9b3fe5ac943fd864103", size = 3191794, upload-time = "2026-09-01T01:10:36.384Z" }, - { url = "https://files.pythonhosted.org/packages/3f/37/168de95e75ef186e609ce8bd2dcdfa9a0b59b987feee9618b6b85fd4cd22/pymssql-2.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf133b27a6e9afbabcd13ddbcb424d63a5ce05df0dfbfc90a7df5bfc303d4ae9", size = 3715635, upload-time = "2026-09-01T01:10:38.35Z" }, - { url = "https://files.pythonhosted.org/packages/d5/e7/936d35117b804611c8e44cddfab4cd3d50b8d7e402c8ca337aba16437f35/pymssql-2.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:dfdcd1495d4884741fa8a38d6836620d1bd258f14c8548e82335a73f4186edb0", size = 3462275, upload-time = "2026-09-01T01:10:40.285Z" }, - { url = "https://files.pythonhosted.org/packages/5f/2f/16b9250fcba9711e8d6fd962c063754bb75ce2ff0ddd88a3899e42b9feea/pymssql-2.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:042cf32e40a09b3ead1b506da702552858ea7f008d0e6dea44fbb888b497dbc1", size = 2348785, upload-time = "2026-09-01T01:10:41.958Z" }, - { url = "https://files.pythonhosted.org/packages/d0/fb/d51321a65fb3af74d3e2ecdefc36e67b10b1d6e31da1dae849e231ce32df/pymssql-2.4.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:6abda3d17d621c394d5fafba907032f56b532f76d7b459f1c6387ae3a34b2908", size = 3201677, upload-time = "2026-09-01T01:10:43.737Z" }, - { url = "https://files.pythonhosted.org/packages/c7/05/c42ae5d2df0e278e17e906b9570c32f1607090c2530583de5d2a8d545b21/pymssql-2.4.0-cp311-cp311-macosx_15_0_x86_64.whl", hash = "sha256:3bc8b71ae1b8fd6179ab5da0b92e04f03ce852b8dc44c8de88031b406552ff63", size = 3006638, upload-time = "2026-09-01T01:10:45.409Z" }, - { url = "https://files.pythonhosted.org/packages/60/09/04566a5e4fe8ba272a35d5710c91fadd11e7df2f5eee77586eb7ddfd8cc6/pymssql-2.4.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3c76d894e690b0be21b56e9d10d58bc37cf592d237754a51191dc6295c44445", size = 3051882, upload-time = "2026-09-01T01:10:47.022Z" }, - { url = "https://files.pythonhosted.org/packages/f4/01/ae3747b57afaa407ac79b348070591d73f1bb96a157dd5465b9c242abe8a/pymssql-2.4.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ade26b9bb6369189c413e33f036472e4bb962d2ff314877b6ccb6b8d4a906e64", size = 3180266, upload-time = "2026-09-01T01:10:49.114Z" }, - { url = "https://files.pythonhosted.org/packages/31/7c/3c2a38d83a348197d14024e75137f30331f65d8223e0175f3283780958a1/pymssql-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2b5957f4cf209d78ce87a4471f32243f1d040169b578b91aa4c988ba786cbc14", size = 3707650, upload-time = "2026-09-01T01:10:50.714Z" }, - { url = "https://files.pythonhosted.org/packages/07/0d/b15bf904821b4f99dc43bf6b7a484cbd1959e633683788a0b4dbb4542db3/pymssql-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:82cf29f1b3c8793cc1122aae2c1bb77f754dbcd0d9bbc13c7ce45430ffdbb448", size = 3448633, upload-time = "2026-09-01T01:10:52.441Z" }, - { url = "https://files.pythonhosted.org/packages/86/7f/a0e259367595e5ea3166964852721be8270414fffb4da7612c6f9d371705/pymssql-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:1ad5ac94a03bc202acf98437a2e2b277743c5b023da4c7b1b707b2902eb139cb", size = 2348546, upload-time = "2026-09-01T01:10:53.996Z" }, - { url = "https://files.pythonhosted.org/packages/d1/b7/0f4023625f5100ee78887ddeacc5521f9a6854637485171df51d7275899c/pymssql-2.4.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:b431102558c76530505746f2ea8167fcc7d1deb1c50c797f36181dbfe366050b", size = 3183355, upload-time = "2026-09-01T01:10:56.003Z" }, - { url = "https://files.pythonhosted.org/packages/69/9c/9b644e6e995f75a5d8b6e51fd98855014ef79d0ef5845128981b8b0da00e/pymssql-2.4.0-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:e0890069d3d4afb608674315e0c7b1f9290ca33d1bd6424f8373f81ace79c016", size = 2988416, upload-time = "2026-09-01T01:10:58.156Z" }, - { url = "https://files.pythonhosted.org/packages/e6/26/df87ca403407c8d30e4070553bbbc1c9b36f4eaaf3648fdd18f40238028c/pymssql-2.4.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:300c9bec2497d260854f70f25bf45ef115b08aa51238f146da664dcbb0b5b0e5", size = 3081233, upload-time = "2026-09-01T01:11:00.197Z" }, - { url = "https://files.pythonhosted.org/packages/22/6d/f27d0de50afde20b740c56d00753b9491b3a673ad9acc5d0d04d046bc852/pymssql-2.4.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1b0b0c09f15ac96fd7f802db7fdf0d8ad5537ccd90db0f3a92737f489f8f0ff8", size = 3207243, upload-time = "2026-09-01T01:11:02.379Z" }, - { url = "https://files.pythonhosted.org/packages/6e/78/eac9c5be5d75bfd5021f2856461f7475c15fba834208bec13bbeaa696fec/pymssql-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:885f4db0c4fdba922bf100da015102750b758d5ebc3c7244598ad47b159f7b05", size = 3735355, upload-time = "2026-09-01T01:11:04.382Z" }, - { url = "https://files.pythonhosted.org/packages/10/ea/ab00eabe80833640dc0eda8ebfbfc8eb657fcae4a3a9c29a65a0d9fb08f5/pymssql-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1a7b77015c5e92ea718809fa6299f6cd8e54c39ef1837fdd1d18e9b09827ae3f", size = 3476353, upload-time = "2026-09-01T01:11:06.192Z" }, - { url = "https://files.pythonhosted.org/packages/74/c2/f0b2bb24fd50b10f961ea3c52b6317b7292f26a26e8c467e8713cb263b08/pymssql-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:14d42964bc0bc6d238eb6579d3f1761d13f1af8872fe40725f850afabd29004f", size = 2332799, upload-time = "2026-09-01T01:11:08.176Z" }, - { url = "https://files.pythonhosted.org/packages/92/70/b1ec693c334a0c7d3e311a47d4fc0984200e93893bb7b3111223d4ca895a/pymssql-2.4.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f24a8e26fa24bcb54fc1e42ecc7e04d31386ae341ef24a0ce5ab28825c1e6b60", size = 3184317, upload-time = "2026-09-01T01:11:09.982Z" }, - { url = "https://files.pythonhosted.org/packages/84/ac/0cf83c7ab51aeeae44ae268b050adc6b7a3fc8e39b29725a95a0709eee67/pymssql-2.4.0-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:9abd2bdd3fdec4b204619a6e2879f700d6ea3579ecf7183461dcd28c7c3ca447", size = 2993292, upload-time = "2026-09-01T01:11:12.002Z" }, - { url = "https://files.pythonhosted.org/packages/bb/bf/a3e5730fd70f1e709c34f42c5ae8cf7358c0f8ca3b9c65808d977b3f8b8c/pymssql-2.4.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a950900b76d90d7778a42e5fab6a03d82136a78e5800be7a148cef3c0b5a3700", size = 3080703, upload-time = "2026-09-01T01:11:14.031Z" }, - { url = "https://files.pythonhosted.org/packages/44/ca/a84d975093b1304259b1716a2ad2685d7bef9fcb865dcf0ab773f1d97280/pymssql-2.4.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fcfd3f118a5073e4f41bcd1d96e65606e31c140a8e692e051d3f0c4833c259bc", size = 3206695, upload-time = "2026-09-01T01:11:15.814Z" }, - { url = "https://files.pythonhosted.org/packages/29/fb/829053bdc60aaf1a4f11eefccc36039c43177ef5b9b6f8cb9a36068cca61/pymssql-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0019a0301489f259c61fb8a8f9204e0405763763b26818a3a1c1988ac821a4b5", size = 3734690, upload-time = "2026-09-01T01:11:17.638Z" }, - { url = "https://files.pythonhosted.org/packages/cc/80/f4cae99188710afd3261082d84f9ab4f981561d460453893e0961fecbd7a/pymssql-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7c903cb903337a3a668c32f647d7d91d87a038f65e055155d09415db843e6bb0", size = 3475952, upload-time = "2026-09-01T01:11:19.648Z" }, - { url = "https://files.pythonhosted.org/packages/e0/80/ce4bfd451ca5093c9b1863f5f3ee043f37075691fa034e823fdc4d6f9d6d/pymssql-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:18d0539d88d245a21cb348f8b46ce517ca0d93c44c502becb7849ca288c57fcd", size = 2331943, upload-time = "2026-09-01T01:11:21.495Z" }, - { url = "https://files.pythonhosted.org/packages/96/15/8359d085ef0870f7cf78ac88b2f336e9971ae8e002478aa640a508efe2f6/pymssql-2.4.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:10ad9b17fd6203448b0bcacd1e08eaec52a1c22f2acbc939d48c083f4452054a", size = 3186738, upload-time = "2026-09-01T01:11:23.267Z" }, - { url = "https://files.pythonhosted.org/packages/c3/fc/de2a1224ecbafae2ddbe73dc6599a8a43d68faf7dbcf98eec29252864c32/pymssql-2.4.0-cp314-cp314-macosx_15_0_x86_64.whl", hash = "sha256:ef686f87269f977bc13d6b644d6bb04257ef21477a548313e35ca228794141a6", size = 2994778, upload-time = "2026-09-01T01:11:24.851Z" }, - { url = "https://files.pythonhosted.org/packages/bd/e1/1a10660bc19cb6f07801008c04de45a7be3ac5df61a69c71540e8452c63d/pymssql-2.4.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7794af8c8c85f38a973c7c5b3d4297db4deb1a4c65a13a75b327d1258127940c", size = 3079122, upload-time = "2026-09-01T01:11:26.809Z" }, - { url = "https://files.pythonhosted.org/packages/8e/5a/cfcbf648d141647c057acbb7db27c5be2a135cce8dc23247aec30fffd257/pymssql-2.4.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:adb6e6079354a0b3e1d3fb03bcddf1103d2bf2824eb8ae6f675ee7236cc3c676", size = 3204659, upload-time = "2026-09-01T01:11:28.491Z" }, - { url = "https://files.pythonhosted.org/packages/f1/e5/c0dbc28629844164d517f2b0dfdc68b8e4820bf216075bf001713001c520/pymssql-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b4e2708c017c50dd738c08457de38f7b95a67518ced4afb00da481015b54db6d", size = 3733454, upload-time = "2026-09-01T01:11:30.295Z" }, - { url = "https://files.pythonhosted.org/packages/fc/4f/d8cb47ae7e3de90314d644dc1c6891f5c73763185731a64009a3172af76d/pymssql-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c1d6836dffd97b4a582df00fe4e5b18340823ef547a7ee0124adb4a5f0b80ddf", size = 3474202, upload-time = "2026-09-01T01:11:32.048Z" }, - { url = "https://files.pythonhosted.org/packages/61/af/596bdc78f7bc7df7d38c4179177811b047eaf6d96fa8d8c68398071dd2e0/pymssql-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:d8e83295a53112259a461af84e5c63cefc32fdec97a682a11c76728296e8cefd", size = 2394490, upload-time = "2026-09-01T01:11:33.741Z" }, - { url = "https://files.pythonhosted.org/packages/77/f3/11397f745bc741980de23f54c2b06e577345b94110c7a3ee3f25f23eae33/pymssql-2.4.0-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:b0fc1f0333345a491a0f7a4b053513d8f296d846ff81b96d7c789436787b139a", size = 3185774, upload-time = "2026-09-01T01:11:36.287Z" }, - { url = "https://files.pythonhosted.org/packages/26/01/078ef5ae28f175ee6a094517ea409e7334300cbdbf1bf6f8b0db6fbbb5f8/pymssql-2.4.0-cp315-cp315-macosx_15_0_x86_64.whl", hash = "sha256:2f0b1617af692e52602a5d9663e641aea8e86a657ae7cac322c62dbb56031ab5", size = 2993613, upload-time = "2026-09-01T01:11:38.817Z" }, - { url = "https://files.pythonhosted.org/packages/50/7c/c6af15e328d7ad7a35d5000a1e97422495fd0fcbf2932d9c29ea5488b636/pymssql-2.4.0-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4dcceddc617689ceb818e910151bff966abe42dfd1ca8cc529605f04330bc178", size = 3079463, upload-time = "2026-09-01T01:11:40.521Z" }, - { url = "https://files.pythonhosted.org/packages/44/e7/b943cee9ef419b75871d619fe5317d885d1ce60762c3288af1b1a0bb0088/pymssql-2.4.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:2680c03be13c0b48477fa98b5e18f255e77d70805243dea777779a841fee0bb1", size = 3733869, upload-time = "2026-09-01T01:11:42.376Z" }, - { url = "https://files.pythonhosted.org/packages/c0/6f/bb8efe2d0a1772b084e6deeacc357f536fb92c2bd60a15508a3a33853373/pymssql-2.4.0-cp315-cp315-win_amd64.whl", hash = "sha256:7432702cd4449a027222d66c52acab3dc7f12d2ed416181ae4274e44ea641ce8", size = 2393569, upload-time = "2026-09-01T01:11:43.984Z" }, +sdist = { url = "https://files.pythonhosted.org/packages/4c/fa/00f1d56d38ce3d070602ba3687079b961b4fcbbf5085f83f92dcf5d924ba/pymssql-2.4.1.tar.gz", hash = "sha256:16720f33d7dcfc7ef906cad8d182f05ba7e5d2c35c6be6a5bc17ce5edfc428b2", size = 208142, upload-time = "2026-09-07T20:52:19.316Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/7a/1777dedad1d31a57dea21db4b7b57014badd6d6269ed6e0ebddc39b7d78f/pymssql-2.4.1-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:cf5fc51c6a4b6c1fcd2c1daad03b839345a6d420ddbb6b163fdfe5eab4b9782f", size = 3209539, upload-time = "2026-09-07T20:50:39.349Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9e/0446fe39324db294b3b6922b7733850a6b16158b0f82d153b6846ec4f931/pymssql-2.4.1-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:bd824fd07c418e604aeb79a1ba18171b940cc1bdbf535fc90622e370cd77a517", size = 3014275, upload-time = "2026-09-07T20:50:41.228Z" }, + { url = "https://files.pythonhosted.org/packages/ca/9b/32889104988dfea633fd156c9fa9306f80ff317060e03991b2d82dbdac1d/pymssql-2.4.1-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7ee1b4f8b8cba79df58e0a8d09c3750a4f4f59c17c67c47f414199f915912678", size = 3064266, upload-time = "2026-09-07T20:50:42.603Z" }, + { url = "https://files.pythonhosted.org/packages/66/88/5142e8bab5a604032e1c9ce7832474a9dfb01f8b91375d0847bb81dece8e/pymssql-2.4.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8399d84c2c9ac245592b513a2b18c6de3d6ebc4196a87ba3e6d3a4d4fdf43f3d", size = 3195463, upload-time = "2026-09-07T20:50:44.253Z" }, + { url = "https://files.pythonhosted.org/packages/ce/04/e80a214766bbd36ce1d63c86e9d566c96805aa29577dd2176ad29baa8720/pymssql-2.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:1dfa18f2c46d72b675430d87e9fb8a12f2746aa418ff78e635e4f7c247f3745e", size = 3719173, upload-time = "2026-09-07T20:50:45.698Z" }, + { url = "https://files.pythonhosted.org/packages/2f/19/810da50a13413a42470f6c37ea3b14f2099eab915132b9873e40683811c4/pymssql-2.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d1bcc46063e3eadd6d7d359c1d08fe9bcd46c6c674c83495f150582f09b018b3", size = 3466086, upload-time = "2026-09-07T20:50:47.477Z" }, + { url = "https://files.pythonhosted.org/packages/02/e2/e0a486bdaaa1b5fd47482cdf110711302853fb611d5d82509c47168b4117/pymssql-2.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:613cb873cbcad9acb232ff448156ce878ab2cc9cbdeb08d91911c28868a6c786", size = 2350433, upload-time = "2026-09-07T20:50:49.211Z" }, + { url = "https://files.pythonhosted.org/packages/96/f2/c5eb7f7032580fde552f6900517575fc79d7460a4d60ee3f80a24c87d172/pymssql-2.4.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:47d383d45ae13480211345b476fce9d8ad02264c1d3aea4781e9c8f06fa07a95", size = 3208157, upload-time = "2026-09-07T20:50:50.656Z" }, + { url = "https://files.pythonhosted.org/packages/af/0f/218b62860854f459af263a7b1d0c562dfed0f4f587ce56afd3ee922dca66/pymssql-2.4.1-cp311-cp311-macosx_15_0_x86_64.whl", hash = "sha256:e15a07b448bfa5626b166555be96b6bc56c3dfb0982d2b355eacfeb03574a50e", size = 3012474, upload-time = "2026-09-07T20:50:52.217Z" }, + { url = "https://files.pythonhosted.org/packages/36/ae/bc56f0cde5554c3c70de7ea8ca666d4b20103352d7dab138b948c91d5032/pymssql-2.4.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:26bf66f8b7c06d41523b5e58972a2c404021fd20e50e2dce36dec0b5923b1146", size = 3054819, upload-time = "2026-09-07T20:50:53.598Z" }, + { url = "https://files.pythonhosted.org/packages/ee/57/168d56ef8a6509f0a4e8d279acbe7a454b2e250f1e796fb54faa81ca4850/pymssql-2.4.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2dd48984a8bd678f57126ec28f1393b35295c7ac60c44f8e0d640d4839c6fa3", size = 3183990, upload-time = "2026-09-07T20:50:55.27Z" }, + { url = "https://files.pythonhosted.org/packages/19/2d/cd69bb7177c60b725a9db16382b62f24b324b76d8e7f76b4e3bceeddac0d/pymssql-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a46d55470a0e142b5dd1f15f9de519d35a80c89db6131dccdfab694209e5065b", size = 3710502, upload-time = "2026-09-07T20:50:56.881Z" }, + { url = "https://files.pythonhosted.org/packages/f2/eb/6fb7fcb35c9d95753d75b0ba1cdfaa3325989b0be65520e2a7fd88722857/pymssql-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:2affd3b80a28b12471ae09cf5e2386b30019991a11cd3ff32e1e46066a183ac0", size = 3452543, upload-time = "2026-09-07T20:50:58.299Z" }, + { url = "https://files.pythonhosted.org/packages/79/75/dadff01e34e1c04bec312c07408d3f65965b589ea0209b0ebc20ba0f9dc0/pymssql-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:8dc745dd2f37aae6f7353e3a79bc8811d4098dc6ab4f3fcc754faea0db677d7c", size = 2350268, upload-time = "2026-09-07T20:50:59.593Z" }, + { url = "https://files.pythonhosted.org/packages/33/3f/ee6f3d51cefeb60c1d32351c80743ad711068f5ade76e7d04e95927ce6ff/pymssql-2.4.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:097df7b0fd55274f2b2fbb15fdee40e3ef5e72a56dc87182aadaf1fa763c7864", size = 3190268, upload-time = "2026-09-07T20:51:00.952Z" }, + { url = "https://files.pythonhosted.org/packages/11/3e/c80c91e1d617e1a0ff5daebeb81cb696a54a6792c56b4ea6a524513de615/pymssql-2.4.1-cp312-cp312-macosx_15_0_x86_64.whl", hash = "sha256:3b88d66baad723d3f78f646c909ff3c02274b96bb543899a7139f70ec8221b42", size = 2993734, upload-time = "2026-09-07T20:51:02.42Z" }, + { url = "https://files.pythonhosted.org/packages/a0/76/438f2dc6649900e38d11714d986a10cdbf6a666a67a09fa04cab9258d8dd/pymssql-2.4.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e30b1a1e424f454ddeaf5293eb7758bbafecd4bd336ef15588866d892342cd12", size = 3085313, upload-time = "2026-09-07T20:51:03.882Z" }, + { url = "https://files.pythonhosted.org/packages/1d/ed/d47c1f94eaf5f10d211b90b26d932fab5ae1838619aa2ff6d2c27c35f672/pymssql-2.4.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9732d9689cfdd60d454c5a2236e6ade41dcb86b9f87ee0549cbacae51ff03e43", size = 3212608, upload-time = "2026-09-07T20:51:05.304Z" }, + { url = "https://files.pythonhosted.org/packages/de/b5/f0356904307284debfaed363bd06d6d38ee40352645cd6a19dc073db93d7/pymssql-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:489ea50678fc8f6c1f2950e978b6893333a6bb5450b6aeb1783004f7869cab04", size = 3739568, upload-time = "2026-09-07T20:51:06.89Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5b/b258c5bf6b0e9b241b417a03927b967f740d0b9e06f8c69fedc96e22bea5/pymssql-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6811ac269462d001ffabf9162f939c9358ec10a70a645b7fd6b849009b947ebd", size = 3480815, upload-time = "2026-09-07T20:51:08.611Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c3/3dde3f750a37d071a1ea483c63fdb114036e79278cc974c6b626b5af91b7/pymssql-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:2f5a1e28e4be6e50fea670ae35bf63f53858abb2edf1dbc17f6a2fc037e0db94", size = 2336876, upload-time = "2026-09-07T20:51:10.246Z" }, + { url = "https://files.pythonhosted.org/packages/1f/0d/f0aa8d4aaf9375d05e98ad94c281574c07809400b84cdd2a166b764dcc17/pymssql-2.4.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:27f7d905a25f46b43a7ad136c7989763c4bb34493f56c0d978577ca5aaa65309", size = 3190800, upload-time = "2026-09-07T20:51:11.719Z" }, + { url = "https://files.pythonhosted.org/packages/56/c1/cbbdad100e9650adbc964f4c879e0ecf8b54eb375d13c0fbe4b29fd205a1/pymssql-2.4.1-cp313-cp313-macosx_15_0_x86_64.whl", hash = "sha256:d722aa98efbb8e5fa0d813b1f83862fc7a9fa46adc340a586bf1bcf6a801537b", size = 2999064, upload-time = "2026-09-07T20:51:13.362Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7a/7db5d585f13b1f94552c9520de6caad6001657da6fdc275d2cd10e2edb0a/pymssql-2.4.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f14e19f59f216c169e5992d52350ba501a80858a14120c333bd4aeecbb4d3cf", size = 3084817, upload-time = "2026-09-07T20:51:15.087Z" }, + { url = "https://files.pythonhosted.org/packages/4f/f7/073d33046adcb94e402224bc9af9ccd9cb10d07f9405facb895254f7c3fc/pymssql-2.4.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eaf899774605e79127cc9fcbcf9460192d7413562a28bfea6bf2c083b20bedd3", size = 3212131, upload-time = "2026-09-07T20:51:16.639Z" }, + { url = "https://files.pythonhosted.org/packages/e1/1a/d5e2a350550be9993c36f8d0ffcd62f56222b268a379dd106c5731c0d94a/pymssql-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:870b3891643dbed85025e9ea2cd56c31035dc8facefb564acc56b8742f7a8895", size = 3739060, upload-time = "2026-09-07T20:51:18.39Z" }, + { url = "https://files.pythonhosted.org/packages/e1/a8/469d26da2071ecacb1a2cb86bc42a5032605ba7da4d95ab343db56e2c32b/pymssql-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1b8b4779840c08d26dafe892b38392f632b79ce948191e2f1b03a56ebd937b26", size = 3480354, upload-time = "2026-09-07T20:51:20.15Z" }, + { url = "https://files.pythonhosted.org/packages/19/2d/2d3331c3283732ee10f053b8f056c05995972f34638e14972923a0da9400/pymssql-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:78c643a7f5b0faf2e031b47a2b2086a66f814e1c7ef2505116fff41b14420df8", size = 2336076, upload-time = "2026-09-07T20:51:21.943Z" }, + { url = "https://files.pythonhosted.org/packages/74/73/56f6f1596233e3839a373de505c361d8e35d04eeb0762d4d1e2efa5fb92c/pymssql-2.4.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:c3ce52139a5201ee3158c08d8801d1c2ba9d139e7049faa0aa1a5b8d7c1f7c51", size = 3194212, upload-time = "2026-09-07T20:51:23.474Z" }, + { url = "https://files.pythonhosted.org/packages/2a/b1/e96b78c225594490386ce8b0c4bc1b4b918e609ee8622419f5ebe8c15800/pymssql-2.4.1-cp314-cp314-macosx_15_0_x86_64.whl", hash = "sha256:05b809ebee27311f5a8118f0458442af34c129145603695c716a3e27c34e2d74", size = 3000120, upload-time = "2026-09-07T20:51:25.143Z" }, + { url = "https://files.pythonhosted.org/packages/f6/5b/58d4d146a024498287a87aeea8f40dcc1ec47d19f43e1001235508e3ab1c/pymssql-2.4.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e6ec84412f3593adec8cdb65883910abeee84b2d4f7e1d75bcf2b1c0b1347660", size = 3083072, upload-time = "2026-09-07T20:51:27.06Z" }, + { url = "https://files.pythonhosted.org/packages/1a/3a/11c5136ef781c2d9fea1bd0d1f3d8e127e842756869a060f7e7d1b104d44/pymssql-2.4.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:46c82b8764c7062d3b6ccb75c15a7b0dc556b5d6fee3327450abadc5da0a2ec7", size = 3210524, upload-time = "2026-09-07T20:51:28.597Z" }, + { url = "https://files.pythonhosted.org/packages/52/2a/a73cd654737f7df79a95d3e8ba739acc84000e61f55ac74b8892fe06ff0c/pymssql-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d6e9df554c702afc5c3069b340cdae4ca764d30d6da001d14cb6b077a5a001ad", size = 3737852, upload-time = "2026-09-07T20:51:30.107Z" }, + { url = "https://files.pythonhosted.org/packages/66/f8/1943cb6cbb44ee87db11fbd8800a45c1f5fed89d734e837402ce8816615c/pymssql-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:709da29d82bb0c7237dc68ec16f0fdb273f97120e1795d80f8ffe6c28885b39a", size = 3479021, upload-time = "2026-09-07T20:51:31.776Z" }, + { url = "https://files.pythonhosted.org/packages/15/15/4a075329a1fa3a3159d98d550ed406d3efd4f530caa8b0fd3a284394850f/pymssql-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:0d4ce2c51816a5e3690d749012b7cdfe524f2f7b61d3041c8024e788d205754d", size = 2399181, upload-time = "2026-09-07T20:51:33.744Z" }, + { url = "https://files.pythonhosted.org/packages/1a/f8/e4dfe0d10a1d14eacbfe407fc1d340b1275f31f57fab63be3d983cd6dcfc/pymssql-2.4.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:d0f4b076bc9cd758e0837c5db13ba58ff8259b487c1410adf7ca297b03e3f194", size = 3221687, upload-time = "2026-09-07T20:51:35.241Z" }, + { url = "https://files.pythonhosted.org/packages/dc/58/8d980aaa627259a89ff9fb336cb8b02cce1fe5672cc4a31cfc1666e94590/pymssql-2.4.1-cp314-cp314t-macosx_15_0_x86_64.whl", hash = "sha256:5d92156bda4d27578c87e73c9f9a1f95c6a3de83396bec933ed1c994279e8d3d", size = 3014333, upload-time = "2026-09-07T20:51:36.685Z" }, + { url = "https://files.pythonhosted.org/packages/1d/5c/ff6d55e87f0578273592e75d0476280b4846baf2531fee075910c19e89ba/pymssql-2.4.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cf15d3c41f2fba30f4613b131f9dfd9a91e2de45c5e667278c6363107b6a0465", size = 3076346, upload-time = "2026-09-07T20:51:38.153Z" }, + { url = "https://files.pythonhosted.org/packages/f8/3f/5e135d360180c903d316d850f76a9ee63d88d67790353a038223b892e27d/pymssql-2.4.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a879c978e9f2f5e7fa7bcefca2305c0af7047626982f739af240cfd69d3855b3", size = 3205190, upload-time = "2026-09-07T20:51:39.666Z" }, + { url = "https://files.pythonhosted.org/packages/25/7e/da3cc35c93684a2525996db1e2e6211104a37b1c5c1666333e884b301844/pymssql-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a0c9b201a8e70453411c26b851906bdbe18652098d0b4c0f2008c25c41a056e8", size = 3732362, upload-time = "2026-09-07T20:51:41.753Z" }, + { url = "https://files.pythonhosted.org/packages/3a/2e/79afe886f903e737a09cecd4242b47879b3fbf2a55afc1775e58a3dc18a9/pymssql-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:68771495155af75c7c4ea71f1640bdd23daf58b642d5fa9ec39a977dfa407ec6", size = 3476637, upload-time = "2026-09-07T20:51:43.319Z" }, + { url = "https://files.pythonhosted.org/packages/fd/be/a45930aebb1228e5d39490f3b89865a261e1e9f52c3e0cfb595249189f11/pymssql-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:0e32a066c248a905723f142c3b34231f1c9adbe5d81d8b6157a868e2717937b8", size = 2418568, upload-time = "2026-09-07T20:51:45.213Z" }, + { url = "https://files.pythonhosted.org/packages/d5/34/132a9c1a17f96baa8b99d7123c6b6b93dced772ec5ba3bab8287e65f47f9/pymssql-2.4.1-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:37f7d52c38f6fd7c2752eb2a3751bd21d7a1cba545c227cf1b339a001b8fac8b", size = 3193101, upload-time = "2026-09-07T20:51:47.198Z" }, + { url = "https://files.pythonhosted.org/packages/8d/db/235cfa3fa46c8e052f571ff2f5530389226bc8931f74667c2d7082b4c18f/pymssql-2.4.1-cp315-cp315-macosx_15_0_x86_64.whl", hash = "sha256:490aa41a6b8d92f785510d92a0bbbefb0d31fecc4ede56e675b4ba8067f70b50", size = 2998924, upload-time = "2026-09-07T20:51:48.706Z" }, + { url = "https://files.pythonhosted.org/packages/ef/d1/c6eac814162ac68fe69d5a76e1b169ac8be72fcda27d9f23be14423e9115/pymssql-2.4.1-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:387a9775e03225a1b1cf03d62f6c345556e94149512b7fdf6323a7b1fa187764", size = 3083321, upload-time = "2026-09-07T20:51:50.208Z" }, + { url = "https://files.pythonhosted.org/packages/b1/45/31cf257114e2b5ffa3209c80e8a12ca13937f6b94bfa957a17de4646f932/pymssql-2.4.1-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:77a7d73d661b7ec7e97effa51ee84285ab653bc99617c6b1968d028245e3fba7", size = 3210661, upload-time = "2026-09-07T20:51:51.631Z" }, + { url = "https://files.pythonhosted.org/packages/3d/2a/c02799c3752cc0291c8872878635c127ebd92b46d7765301e02078239708/pymssql-2.4.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:409acdff480ac93d87078febe511908311981944fcdb5a0ba3d708db5c0f0822", size = 3738153, upload-time = "2026-09-07T20:51:53.216Z" }, + { url = "https://files.pythonhosted.org/packages/19/ec/045feaa866015ea36ffd87074070c8672fbf66dc74597f132d8c8e8cfed6/pymssql-2.4.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:8098763793ed83e804bbd2fc45aa0ce635813a862faee886461140f193d2ec26", size = 3479155, upload-time = "2026-09-07T20:51:54.744Z" }, + { url = "https://files.pythonhosted.org/packages/7f/62/46b362c04f74d4440169bb2996cd207d0739dcc0487786f699cdd5219544/pymssql-2.4.1-cp315-cp315-win_amd64.whl", hash = "sha256:79e43dfe669731bcf9824676f389f43f4efe5930e5f715889f4a00f275ba6ef9", size = 2398614, upload-time = "2026-09-07T20:51:56.226Z" }, + { url = "https://files.pythonhosted.org/packages/b7/f6/b38302dcc7ea7f0591b0606a180a73ef41782b8f9b3e3f77a6f24eb71543/pymssql-2.4.1-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:a2794eb20fe69f646f1811318909ef3ed9b727c2d43316757be193463e8d6e86", size = 3221033, upload-time = "2026-09-07T20:51:57.824Z" }, + { url = "https://files.pythonhosted.org/packages/46/7b/1656aa6832a9652f49502bdc6f2ef9bc24a9fb823b343d9e01f07d05c0bf/pymssql-2.4.1-cp315-cp315t-macosx_15_0_x86_64.whl", hash = "sha256:5968c34d324aee93dbe2e649f63f543cd40bd8de6af2708ea5ebd3eb8851b5c3", size = 3013409, upload-time = "2026-09-07T20:51:59.279Z" }, + { url = "https://files.pythonhosted.org/packages/7b/f4/7637f1d7d63aa5b9952deec80b2db7e926323c8f754993571a06a9416c32/pymssql-2.4.1-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:87a0e293608a20b98c24d3b9cd744d32d92593e4323089ac0e97cad370bc234f", size = 3075820, upload-time = "2026-09-07T20:52:00.814Z" }, + { url = "https://files.pythonhosted.org/packages/2d/41/a54eb4154bb580fdbaf133f720197df1f4dbc999a510ea7080845b42c5ea/pymssql-2.4.1-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70083f1b3e7b83892735594f76dbb1119abffe7dc0a7eb878338e8cb08b2b847", size = 3204474, upload-time = "2026-09-07T20:52:02.479Z" }, + { url = "https://files.pythonhosted.org/packages/76/c1/f7c39f9e700fbed2ddb34ee70ca2dfc8af8ab7aa8f80665c58df690a38c2/pymssql-2.4.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:e6fb52f61248cedab757880099f441cb2e97f34e527089f59df2c17a76f92e33", size = 3731724, upload-time = "2026-09-07T20:52:04.001Z" }, + { url = "https://files.pythonhosted.org/packages/c2/79/0554b8a6c0909b3de53793d2f832109e31b18e881c43ca697ef9888fe8ed/pymssql-2.4.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:2e0abf167dd198b8f865a5fec4601256ee0e95658ee748ba632072aa84480bdb", size = 3476013, upload-time = "2026-09-07T20:52:05.596Z" }, + { url = "https://files.pythonhosted.org/packages/bd/ba/ae38159179308f2ef630c49bca3f6f3760d4e83d532ac10f633bfb29595b/pymssql-2.4.1-cp315-cp315t-win_amd64.whl", hash = "sha256:13f2136deda8ba7c5f3e91797d709548541d34c81067355dc77194e08a0eb995", size = 2416862, upload-time = "2026-09-07T20:52:07.022Z" }, ] [[package]] @@ -5714,14 +5730,14 @@ wheels = [ [[package]] name = "slotscheck" -version = "0.20.1" +version = "0.21.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "tomli", marker = "python_full_version < '3.11'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ae/dc/46346431b07aefd028e48569b8b4a067a7604f98559a14e848d90febaea0/slotscheck-0.20.1.tar.gz", hash = "sha256:f590fddcea4b673f6ef3ee0010a545df1cad96941ef09906b28b2ee31c38c66b", size = 14747, upload-time = "2026-07-05T13:23:28.803Z" } +sdist = { url = "https://files.pythonhosted.org/packages/33/34/811f9588dbd55e3adee986e53cd1bcdfabc6c5b6919b9cf1ff208f2878cd/slotscheck-0.21.0.tar.gz", hash = "sha256:0a5296300c5d5d9663e597861d7b3ef16abc74c851498a648116d868960c12c2", size = 15354, upload-time = "2026-09-06T19:08:07.131Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/59/e9/232563e90b04c3ddd93af1a6ecf8ff8566ad7bb80e46843c472c36f2578c/slotscheck-0.20.1-py3-none-any.whl", hash = "sha256:e8ec875fc40e37660babb28805294615d5631bb09c51ee75db08d03d4b6c156e", size = 17634, upload-time = "2026-07-05T13:23:27.53Z" }, + { url = "https://files.pythonhosted.org/packages/e1/51/778abe936884e73944d43267bed0eae1da0658b11c7d6eb7e10ce83a646b/slotscheck-0.21.0-py3-none-any.whl", hash = "sha256:c109206db56ee48b3862feccd8c44ca480bb4d102ec39f6cc0f8a9695ef17eb0", size = 18076, upload-time = "2026-09-06T19:08:05.937Z" }, ] [[package]] @@ -6258,7 +6274,7 @@ wheels = [ [[package]] name = "sqlspec" -version = "0.63.0" +version = "0.63.1" source = { editable = "." } dependencies = [ { name = "mypy-extensions" }, @@ -6930,20 +6946,20 @@ wheels = [ [[package]] name = "types-protobuf" -version = "7.35.1.20260827" +version = "7.35.1.20260906" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/44/07/541ffc94a4baee7d92ec91d91018aa684f97ece608b74619863e3cfd9cb3/types_protobuf-7.35.1.20260827.tar.gz", hash = "sha256:5a98c18177cfd968d6a0de55ecfc4221aa829ef88bcd86104298e028516b04af", size = 69646, upload-time = "2026-08-27T12:06:04.93Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e1/6c/e3e5b3e10bc328126a39637c138f9ebfd734bf14342b9f3540039b4ab995/types_protobuf-7.35.1.20260906.tar.gz", hash = "sha256:efd1a3862d4c967dad5512ef8d56b1530ac84f182c41735b94004756518c4998", size = 69895, upload-time = "2026-09-06T06:35:28.308Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/01/e2/7ce7c4802bcf3732155dedc23fe3d2b506a387d6b42da61261886f42af80/types_protobuf-7.35.1.20260827-py3-none-any.whl", hash = "sha256:7cc452a012678a6a889287d4cb702ea54b9f90a6ab0f3aa4c019d21f3ae7529b", size = 86412, upload-time = "2026-08-27T12:06:03.826Z" }, + { url = "https://files.pythonhosted.org/packages/44/4e/f63e826c68f77ef875506d72f225918800346545ee99847bc28f3394f18d/types_protobuf-7.35.1.20260906-py3-none-any.whl", hash = "sha256:5155e48569e0dabff303fdf578db96cd31ea9a4a63b18018a4ceac6b0ae17462", size = 86419, upload-time = "2026-09-06T06:35:27.247Z" }, ] [[package]] name = "types-psutil" -version = "7.2.2.20260827" +version = "7.2.2.20260906" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/89/ea/23a949b56d3a226a142b43c5c32404fae7044400296d18e8eda63d5d03a4/types_psutil-7.2.2.20260827.tar.gz", hash = "sha256:3c6067dba47c700495ca493f07b11e866ba13de223aabb26da555f9c86ae0b1f", size = 27294, upload-time = "2026-08-27T12:06:22.279Z" } +sdist = { url = "https://files.pythonhosted.org/packages/97/0a/f48b9b0ab5ba8599fd117309e345152bf82c756c72be2ff0f635780c2792/types_psutil-7.2.2.20260906.tar.gz", hash = "sha256:93abf22cf9a62b915f724e433bde702995ac274865425fd4a76d1d9b5828da1a", size = 27396, upload-time = "2026-09-06T06:35:24.499Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4b/1b/7e0f5cfad4faa4a2e0845f69e9206eeefc6659dfa11d07da04e2fa47d08b/types_psutil-7.2.2.20260827-py3-none-any.whl", hash = "sha256:62364359cf85482aa698a62488e5420cae5c576e8acec450ce7fb3b91cdb3d96", size = 33365, upload-time = "2026-08-27T12:06:21.444Z" }, + { url = "https://files.pythonhosted.org/packages/eb/8d/81a86107486e1c23f5ca21bea1e9e5b18a50754242e7a0b82f41f9ae8384/types_psutil-7.2.2.20260906-py3-none-any.whl", hash = "sha256:db00baf7f96c3f63421c4d3d68d373923094a0dfddf13e922c5c5fbc42488159", size = 33383, upload-time = "2026-09-06T06:35:23.575Z" }, ] [[package]] @@ -6975,14 +6991,14 @@ wheels = [ [[package]] name = "types-requests" -version = "2.33.0.20260712" +version = "2.33.0.20260906" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "urllib3" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/db/51/703318f7b7be8bee126ec13bf615050f932d0179b8784420f3a0199cc769/types_requests-2.33.0.20260712.tar.gz", hash = "sha256:2141b67ab534a5c5cd2dac5034f2a35f42e699c5bf185eee608c5246a069d7fb", size = 25084, upload-time = "2026-07-12T05:14:20.455Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c0/18/4c2c0290953f8b3b9612adfcb07b57f144ade3ad32a76764fca42b77c5f3/types_requests-2.33.0.20260906.tar.gz", hash = "sha256:76ab8a0fb736744a0c3deee7aa57b2927e301f078d9e61f5391b3e92002416b9", size = 25263, upload-time = "2026-09-06T06:35:47.707Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/62/e7/010c87f559e216d83f9dc51e939633fd0d0ead3377340181ab0e223cd3b5/types_requests-2.33.0.20260712-py3-none-any.whl", hash = "sha256:de027e28c171d3da529689cbfa023b0b4eab188c8dfa22fd834eebd2cee6e7bb", size = 21392, upload-time = "2026-07-12T05:14:19.616Z" }, + { url = "https://files.pythonhosted.org/packages/60/4c/51ec821d22a45b4162fa3f3e9e94ea4c0f8c49e82363b10955baa5438391/types_requests-2.33.0.20260906-py3-none-any.whl", hash = "sha256:9f53622652bd921ead7a54d665be1b8d518165c8b51cc9d68d944cd6b6bfa8fb", size = 21461, upload-time = "2026-09-06T06:35:45.856Z" }, ] [[package]]