diff --git a/.copier/.copier-answers.yml.jinja b/.copier/.copier-answers.yml.jinja deleted file mode 100644 index 0028a2398a..0000000000 --- a/.copier/.copier-answers.yml.jinja +++ /dev/null @@ -1 +0,0 @@ -{{ _copier_answers|to_json -}} diff --git a/.copier/update_dotenv.py b/.copier/update_dotenv.py deleted file mode 100644 index 6576885626..0000000000 --- a/.copier/update_dotenv.py +++ /dev/null @@ -1,26 +0,0 @@ -from pathlib import Path -import json - -# Update the .env file with the answers from the .copier-answers.yml file -# without using Jinja2 templates in the .env file, this way the code works as is -# without needing Copier, but if Copier is used, the .env file will be updated -root_path = Path(__file__).parent.parent -answers_path = Path(__file__).parent / ".copier-answers.yml" -answers = json.loads(answers_path.read_text()) -env_path = root_path / ".env" -env_content = env_path.read_text() -lines = [] -for line in env_content.splitlines(): - for key, value in answers.items(): - upper_key = key.upper() - if line.startswith(f"{upper_key}="): - if " " in value: - content = f"{upper_key}={value!r}" - else: - content = f"{upper_key}={value}" - new_line = line.replace(line, content) - lines.append(new_line) - break - else: - lines.append(line) -env_path.write_text("\n".join(lines)) diff --git a/.python-version b/.python-version new file mode 100644 index 0000000000..e4fba21835 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.12 diff --git a/TASK.md b/TASK.md new file mode 100644 index 0000000000..cbe125a0a0 --- /dev/null +++ b/TASK.md @@ -0,0 +1,24 @@ +# Backend task for implementation + +Create a backend endpoints which implements following functionality: + +- Introduce a new entity Wallet and Transaction. +- Wallet should have fields: id, user_id (foreign key to User), balance (float), currency (string). +- Available currencies: USD, EUR, RUB. +- Transaction should have fields: id, wallet_id (foreign key to Wallet), amount (float), type (enum: 'credit', 'debit'), timestamp (datetime), currency (string). +- Implement endpoint to create a wallet for a user. +- Implement endpoint to get wallet details including current balance. +- Implement endpoint to create a transaction (credit or debit) for a wallet. + +# Rules for wallet + +- A user can have three wallets. +- Wallet balance should start at 0.0. +- Arithmetic operations on balance should be precise up to two decimal places. + +# Rules for transaction + +- For 'credit' transactions, the amount should be added to the wallet balance. +- For 'debit' transactions, the amount should be subtracted from the wallet balance. +- Ensure that the wallet balance cannot go negative. If a debit transaction would cause the balance to go negative, the transaction should be rejected with an appropriate error message. +- Transaction between wallets with different currencies must be converted using a fixed exchange rate (you can hardcode some exchange rates for simplicity) and fees should be applied. diff --git a/backend/app/alembic/__init__.py b/backend/app/alembic/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/app/alembic/env.py b/backend/app/alembic/env.py old mode 100755 new mode 100644 index 7f29c04680..9496ba92a4 --- a/backend/app/alembic/env.py +++ b/backend/app/alembic/env.py @@ -1,8 +1,12 @@ -import os +"""Alembic configuration for database migrations.""" + from logging.config import fileConfig from alembic import context from sqlalchemy import engine_from_config, pool +from sqlmodel import SQLModel + +from app.core.config import settings # this is the Alembic Config object, which provides # access to the values within the .ini file in use. @@ -10,30 +14,18 @@ # Interpret the config file for Python logging. # This line sets up loggers basically. -fileConfig(config.config_file_name) - -# add your model's MetaData object here -# for 'autogenerate' support -# from myapp import mymodel -# target_metadata = mymodel.Base.metadata -# target_metadata = None - -from app.models import SQLModel # noqa -from app.core.config import settings # noqa +if config.config_file_name: + fileConfig(config.config_file_name) target_metadata = SQLModel.metadata -# other values from the config, defined by the needs of env.py, -# can be acquired: -# my_important_option = config.get_main_option("my_important_option") -# ... etc. - -def get_url(): +def get_url() -> str: + """Get database URL from settings.""" return str(settings.SQLALCHEMY_DATABASE_URI) -def run_migrations_offline(): +def run_migrations_offline() -> None: """Run migrations in 'offline' mode. This configures the context with just a URL @@ -47,21 +39,24 @@ def run_migrations_offline(): """ url = get_url() context.configure( - url=url, target_metadata=target_metadata, literal_binds=True, compare_type=True + url=url, + target_metadata=target_metadata, + literal_binds=True, + compare_type=True, ) with context.begin_transaction(): context.run_migrations() -def run_migrations_online(): +def run_migrations_online() -> None: """Run migrations in 'online' mode. In this scenario we need to create an Engine and associate a connection with the context. """ - configuration = config.get_section(config.config_ini_section) + configuration = config.get_section(config.config_ini_section) or {} configuration["sqlalchemy.url"] = get_url() connectable = engine_from_config( configuration, @@ -71,7 +66,9 @@ def run_migrations_online(): with connectable.connect() as connection: context.configure( - connection=connection, target_metadata=target_metadata, compare_type=True + connection=connection, + target_metadata=target_metadata, + compare_type=True, ) with context.begin_transaction(): diff --git a/backend/app/alembic/versions/1a31ce608336_add_cascade_delete_relationships.py b/backend/app/alembic/versions/1a31ce608336_add_cascade_delete_relationships.py index 10e47a1456..b75a2c62e8 100644 --- a/backend/app/alembic/versions/1a31ce608336_add_cascade_delete_relationships.py +++ b/backend/app/alembic/versions/1a31ce608336_add_cascade_delete_relationships.py @@ -1,37 +1,52 @@ -"""Add cascade delete relationships +"""Add cascade delete relationships. Revision ID: 1a31ce608336 Revises: d98dd8ec85a3 Create Date: 2024-07-31 22:24:34.447891 """ -from alembic import op -import sqlalchemy as sa -import sqlmodel.sql.sqltypes +import sqlalchemy as sa +from alembic import op # revision identifiers, used by Alembic. -revision = '1a31ce608336' -down_revision = 'd98dd8ec85a3' -branch_labels = None -depends_on = None +revision = "1a31ce608336" +down_revision = "d98dd8ec85a3" +branch_labels: str | None = None +depends_on: str | None = None -def upgrade(): +def upgrade() -> None: + """Upgrade database schema.""" # ### commands auto generated by Alembic - please adjust! ### - op.alter_column('item', 'owner_id', - existing_type=sa.UUID(), - nullable=False) - op.drop_constraint('item_owner_id_fkey', 'item', type_='foreignkey') - op.create_foreign_key(None, 'item', 'user', ['owner_id'], ['id'], ondelete='CASCADE') + op.alter_column( + "item", + "owner_id", + existing_type=sa.UUID(), + nullable=False, + ) + op.drop_constraint("item_owner_id_fkey", "item", type_="foreignkey") + op.create_foreign_key( + None, + "item", + "user", + ["owner_id"], + ["id"], + ondelete="CASCADE", + ) # ### end Alembic commands ### -def downgrade(): +def downgrade() -> None: + """Downgrade database schema.""" # ### commands auto generated by Alembic - please adjust! ### - op.drop_constraint(None, 'item', type_='foreignkey') - op.create_foreign_key('item_owner_id_fkey', 'item', 'user', ['owner_id'], ['id']) - op.alter_column('item', 'owner_id', - existing_type=sa.UUID(), - nullable=True) + op.drop_constraint("item_owner_id_fkey", "item", type_="foreignkey") + op.create_foreign_key( + "item_owner_id_fkey", + "item", + "user", + ["owner_id"], + ["id"], + ) + op.alter_column("item", "owner_id", existing_type=sa.UUID(), nullable=True) # ### end Alembic commands ### diff --git a/backend/app/alembic/versions/9c0a54914c78_add_max_length_for_string_varchar_.py b/backend/app/alembic/versions/9c0a54914c78_add_max_length_for_string_varchar_.py old mode 100755 new mode 100644 index 78a41773b9..915303ee38 --- a/backend/app/alembic/versions/9c0a54914c78_add_max_length_for_string_varchar_.py +++ b/backend/app/alembic/versions/9c0a54914c78_add_max_length_for_string_varchar_.py @@ -1,69 +1,99 @@ -"""Add max length for string(varchar) fields in User and Items models +"""Add max length for string(varchar) fields in User and Items models. Revision ID: 9c0a54914c78 Revises: e2412789c190 Create Date: 2024-06-17 14:42:44.639457 """ -from alembic import op + import sqlalchemy as sa -import sqlmodel.sql.sqltypes +from alembic import op +# Constants +STRING_FIELD_LENGTH = 255 +USER_TABLE = "user" +ITEM_TABLE = "item" # revision identifiers, used by Alembic. -revision = '9c0a54914c78' -down_revision = 'e2412789c190' -branch_labels = None -depends_on = None +revision = "9c0a54914c78" +down_revision = "e2412789c190" +branch_labels: str | None = None +depends_on: str | None = None -def upgrade(): +def upgrade() -> None: + """Upgrade database schema.""" # Adjust the length of the email field in the User table - op.alter_column('user', 'email', - existing_type=sa.String(), - type_=sa.String(length=255), - existing_nullable=False) + op.alter_column( + USER_TABLE, + "email", + existing_type=sa.String(), + type_=sa.String(length=STRING_FIELD_LENGTH), + existing_nullable=False, + ) # Adjust the length of the full_name field in the User table - op.alter_column('user', 'full_name', - existing_type=sa.String(), - type_=sa.String(length=255), - existing_nullable=True) + op.alter_column( + USER_TABLE, + "full_name", + existing_type=sa.String(), + type_=sa.String(length=STRING_FIELD_LENGTH), + existing_nullable=True, + ) # Adjust the length of the title field in the Item table - op.alter_column('item', 'title', - existing_type=sa.String(), - type_=sa.String(length=255), - existing_nullable=False) + op.alter_column( + ITEM_TABLE, + "title", + existing_type=sa.String(), + type_=sa.String(length=STRING_FIELD_LENGTH), + existing_nullable=False, + ) # Adjust the length of the description field in the Item table - op.alter_column('item', 'description', - existing_type=sa.String(), - type_=sa.String(length=255), - existing_nullable=True) + op.alter_column( + ITEM_TABLE, + "description", + existing_type=sa.String(), + type_=sa.String(length=STRING_FIELD_LENGTH), + existing_nullable=True, + ) -def downgrade(): +def downgrade() -> None: + """Downgrade database schema.""" # Revert the length of the email field in the User table - op.alter_column('user', 'email', - existing_type=sa.String(length=255), - type_=sa.String(), - existing_nullable=False) + op.alter_column( + USER_TABLE, + "email", + existing_type=sa.String(length=STRING_FIELD_LENGTH), + type_=sa.String(), + existing_nullable=False, + ) # Revert the length of the full_name field in the User table - op.alter_column('user', 'full_name', - existing_type=sa.String(length=255), - type_=sa.String(), - existing_nullable=True) + op.alter_column( + USER_TABLE, + "full_name", + existing_type=sa.String(length=STRING_FIELD_LENGTH), + type_=sa.String(), + existing_nullable=True, + ) # Revert the length of the title field in the Item table - op.alter_column('item', 'title', - existing_type=sa.String(length=255), - type_=sa.String(), - existing_nullable=False) + op.alter_column( + ITEM_TABLE, + "title", + existing_type=sa.String(length=STRING_FIELD_LENGTH), + type_=sa.String(), + existing_nullable=False, + ) # Revert the length of the description field in the Item table - op.alter_column('item', 'description', - existing_type=sa.String(length=255), - type_=sa.String(), - existing_nullable=True) + op.alter_column( + ITEM_TABLE, + "description", + existing_type=sa.String(length=STRING_FIELD_LENGTH), + type_=sa.String(), + existing_nullable=True, + ) diff --git a/backend/app/alembic/versions/__init__.py b/backend/app/alembic/versions/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/backend/app/alembic/versions/d98dd8ec85a3_edit_replace_id_integers_in_all_models_.py b/backend/app/alembic/versions/d98dd8ec85a3_edit_replace_id_integers_in_all_models_.py old mode 100755 new mode 100644 index 37af1fa215..1252527ab7 --- a/backend/app/alembic/versions/d98dd8ec85a3_edit_replace_id_integers_in_all_models_.py +++ b/backend/app/alembic/versions/d98dd8ec85a3_edit_replace_id_integers_in_all_models_.py @@ -1,90 +1,142 @@ -"""Edit replace id integers in all models to use UUID instead +"""Edit replace id integers in all models to use UUID instead. Revision ID: d98dd8ec85a3 Revises: 9c0a54914c78 Create Date: 2024-07-19 04:08:04.000976 """ -from alembic import op + import sqlalchemy as sa -import sqlmodel.sql.sqltypes +from alembic import op from sqlalchemy.dialects import postgresql - # revision identifiers, used by Alembic. -revision = 'd98dd8ec85a3' -down_revision = '9c0a54914c78' -branch_labels = None -depends_on = None +revision = "d98dd8ec85a3" +down_revision = "9c0a54914c78" +branch_labels: str | None = None +depends_on: str | None = None -def upgrade(): +def upgrade() -> None: + """Upgrade database schema.""" # Ensure uuid-ossp extension is available op.execute('CREATE EXTENSION IF NOT EXISTS "uuid-ossp"') # Create a new UUID column with a default UUID value - op.add_column('user', sa.Column('new_id', postgresql.UUID(as_uuid=True), default=sa.text('uuid_generate_v4()'))) - op.add_column('item', sa.Column('new_id', postgresql.UUID(as_uuid=True), default=sa.text('uuid_generate_v4()'))) - op.add_column('item', sa.Column('new_owner_id', postgresql.UUID(as_uuid=True), nullable=True)) + op.add_column( + "user", + sa.Column( + "new_id", + postgresql.UUID(as_uuid=True), + default=sa.text("uuid_generate_v4()"), + ), + ) + op.add_column( + "item", + sa.Column( + "new_id", + postgresql.UUID(as_uuid=True), + default=sa.text("uuid_generate_v4()"), + ), + ) + op.add_column( + "item", + sa.Column( + "new_owner_id", + postgresql.UUID(as_uuid=True), + nullable=True, + ), + ) # Populate the new columns with UUIDs op.execute('UPDATE "user" SET new_id = uuid_generate_v4()') - op.execute('UPDATE item SET new_id = uuid_generate_v4()') - op.execute('UPDATE item SET new_owner_id = (SELECT new_id FROM "user" WHERE "user".id = item.owner_id)') + op.execute("UPDATE item SET new_id = uuid_generate_v4()") + op.execute( + "UPDATE item SET new_owner_id = " + '(SELECT new_id FROM "user" WHERE "user".id = item.owner_id)', + ) # Set the new_id as not nullable - op.alter_column('user', 'new_id', nullable=False) - op.alter_column('item', 'new_id', nullable=False) + op.alter_column("user", "new_id", nullable=False) + op.alter_column("item", "new_id", nullable=False) # Drop old columns and rename new columns - op.drop_constraint('item_owner_id_fkey', 'item', type_='foreignkey') - op.drop_column('item', 'owner_id') - op.alter_column('item', 'new_owner_id', new_column_name='owner_id') + op.drop_constraint("item_owner_id_fkey", "item", type_="foreignkey") + op.drop_column("item", "owner_id") + op.alter_column("item", "new_owner_id", new_column_name="owner_id") - op.drop_column('user', 'id') - op.alter_column('user', 'new_id', new_column_name='id') + op.drop_column("user", "id") + op.alter_column("user", "new_id", new_column_name="id") - op.drop_column('item', 'id') - op.alter_column('item', 'new_id', new_column_name='id') + op.drop_column("item", "id") + op.alter_column("item", "new_id", new_column_name="id") # Create primary key constraint - op.create_primary_key('user_pkey', 'user', ['id']) - op.create_primary_key('item_pkey', 'item', ['id']) + op.create_primary_key("user_pkey", "user", ["id"]) + op.create_primary_key("item_pkey", "item", ["id"]) # Recreate foreign key constraint - op.create_foreign_key('item_owner_id_fkey', 'item', 'user', ['owner_id'], ['id']) + op.create_foreign_key( + "item_owner_id_fkey", + "item", + "user", + ["owner_id"], + ["id"], + ) -def downgrade(): + +def downgrade() -> None: + """Downgrade database schema.""" # Reverse the upgrade process - op.add_column('user', sa.Column('old_id', sa.Integer, autoincrement=True)) - op.add_column('item', sa.Column('old_id', sa.Integer, autoincrement=True)) - op.add_column('item', sa.Column('old_owner_id', sa.Integer, nullable=True)) + op.add_column("user", sa.Column("old_id", sa.Integer, autoincrement=True)) + op.add_column("item", sa.Column("old_id", sa.Integer, autoincrement=True)) + op.add_column("item", sa.Column("old_owner_id", sa.Integer, nullable=True)) # Populate the old columns with default values # Generate sequences for the integer IDs if not exist - op.execute('CREATE SEQUENCE IF NOT EXISTS user_id_seq AS INTEGER OWNED BY "user".old_id') - op.execute('CREATE SEQUENCE IF NOT EXISTS item_id_seq AS INTEGER OWNED BY item.old_id') - - op.execute('SELECT setval(\'user_id_seq\', COALESCE((SELECT MAX(old_id) + 1 FROM "user"), 1), false)') - op.execute('SELECT setval(\'item_id_seq\', COALESCE((SELECT MAX(old_id) + 1 FROM item), 1), false)') - - op.execute('UPDATE "user" SET old_id = nextval(\'user_id_seq\')') - op.execute('UPDATE item SET old_id = nextval(\'item_id_seq\'), old_owner_id = (SELECT old_id FROM "user" WHERE "user".id = item.owner_id)') + op.execute( + 'CREATE SEQUENCE IF NOT EXISTS user_id_seq AS INTEGER OWNED BY "user".old_id', + ) + op.execute( + "CREATE SEQUENCE IF NOT EXISTS item_id_seq AS INTEGER OWNED BY item.old_id", + ) + + op.execute( + "SELECT setval('user_id_seq', " + 'COALESCE((SELECT MAX(old_id) + 1 FROM "user"), 1), false)', + ) + op.execute( + "SELECT setval('item_id_seq', " + "COALESCE((SELECT MAX(old_id) + 1 FROM item), 1), false)", + ) + + op.execute("UPDATE \"user\" SET old_id = nextval('user_id_seq')") + op.execute( + "UPDATE item SET old_id = nextval('item_id_seq'), " + 'old_owner_id = (SELECT old_id FROM "user" ' + 'WHERE "user".id = item.owner_id)', + ) # Drop new columns and rename old columns back - op.drop_constraint('item_owner_id_fkey', 'item', type_='foreignkey') - op.drop_column('item', 'owner_id') - op.alter_column('item', 'old_owner_id', new_column_name='owner_id') + op.drop_constraint("item_owner_id_fkey", "item", type_="foreignkey") + op.drop_column("item", "owner_id") + op.alter_column("item", "old_owner_id", new_column_name="owner_id") - op.drop_column('user', 'id') - op.alter_column('user', 'old_id', new_column_name='id') + op.drop_column("user", "id") + op.alter_column("user", "old_id", new_column_name="id") - op.drop_column('item', 'id') - op.alter_column('item', 'old_id', new_column_name='id') + op.drop_column("item", "id") + op.alter_column("item", "old_id", new_column_name="id") # Create primary key constraint - op.create_primary_key('user_pkey', 'user', ['id']) - op.create_primary_key('item_pkey', 'item', ['id']) + op.create_primary_key("user_pkey", "user", ["id"]) + op.create_primary_key("item_pkey", "item", ["id"]) # Recreate foreign key constraint - op.create_foreign_key('item_owner_id_fkey', 'item', 'user', ['owner_id'], ['id']) + op.create_foreign_key( + "item_owner_id_fkey", + "item", + "user", + ["owner_id"], + ["id"], + ) diff --git a/backend/app/alembic/versions/e2412789c190_initialize_models.py b/backend/app/alembic/versions/e2412789c190_initialize_models.py index 7529ea91fa..f68491e529 100644 --- a/backend/app/alembic/versions/e2412789c190_initialize_models.py +++ b/backend/app/alembic/versions/e2412789c190_initialize_models.py @@ -1,39 +1,51 @@ -"""Initialize models +"""Initialize models. Revision ID: e2412789c190 Revises: Create Date: 2023-11-24 22:55:43.195942 """ + import sqlalchemy as sa import sqlmodel.sql.sqltypes from alembic import op # revision identifiers, used by Alembic. revision = "e2412789c190" -down_revision = None -branch_labels = None -depends_on = None +down_revision: str | None = None +branch_labels: str | None = None +depends_on: str | None = None -def upgrade(): +def upgrade() -> None: + """Upgrade database schema.""" # ### commands auto generated by Alembic - please adjust! ### op.create_table( "user", sa.Column("email", sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column("is_active", sa.Boolean(), nullable=False), sa.Column("is_superuser", sa.Boolean(), nullable=False), - sa.Column("full_name", sqlmodel.sql.sqltypes.AutoString(), nullable=True), + sa.Column( + "full_name", + sqlmodel.sql.sqltypes.AutoString(), + nullable=True, + ), sa.Column("id", sa.Integer(), nullable=False), sa.Column( - "hashed_password", sqlmodel.sql.sqltypes.AutoString(), nullable=False + "hashed_password", + sqlmodel.sql.sqltypes.AutoString(), + nullable=False, ), sa.PrimaryKeyConstraint("id"), ) op.create_index(op.f("ix_user_email"), "user", ["email"], unique=True) op.create_table( "item", - sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=True), + sa.Column( + "description", + sqlmodel.sql.sqltypes.AutoString(), + nullable=True, + ), sa.Column("id", sa.Integer(), nullable=False), sa.Column("title", sqlmodel.sql.sqltypes.AutoString(), nullable=False), sa.Column("owner_id", sa.Integer(), nullable=False), @@ -46,7 +58,8 @@ def upgrade(): # ### end Alembic commands ### -def downgrade(): +def downgrade() -> None: + """Downgrade database schema.""" # ### commands auto generated by Alembic - please adjust! ### op.drop_table("item") op.drop_index(op.f("ix_user_email"), table_name="user") diff --git a/backend/app/api/deps.py b/backend/app/api/deps.py index c2b83c841d..0e2d7b864c 100644 --- a/backend/app/api/deps.py +++ b/backend/app/api/deps.py @@ -1,3 +1,5 @@ +"""API dependency functions.""" + from collections.abc import Generator from typing import Annotated @@ -8,18 +10,18 @@ from pydantic import ValidationError from sqlmodel import Session -from app.core import security -from app.core.config import settings -from app.core.db import engine +from app import constants +from app.core import config, db, security from app.models import TokenPayload, User reusable_oauth2 = OAuth2PasswordBearer( - tokenUrl=f"{settings.API_V1_STR}/login/access-token" + tokenUrl=f"{config.settings.API_V1_STR}/login/access-token", # noqa: WPS237 ) -def get_db() -> Generator[Session, None, None]: - with Session(engine) as session: +def get_db() -> Generator[Session]: + """Get database session.""" + with Session(db.engine) as session: yield session @@ -27,22 +29,42 @@ def get_db() -> Generator[Session, None, None]: TokenDep = Annotated[str, Depends(reusable_oauth2)] -def get_current_user(session: SessionDep, token: TokenDep) -> User: +def _validate_token(token: str) -> TokenPayload: + """Validate JWT token and return payload.""" try: payload = jwt.decode( - token, settings.SECRET_KEY, algorithms=[security.ALGORITHM] + token, + config.settings.SECRET_KEY, + algorithms=[security.ALGORITHM], ) - token_data = TokenPayload(**payload) - except (InvalidTokenError, ValidationError): + except InvalidTokenError: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail="Could not validate credentials", - ) + ) from None + try: + return TokenPayload(**payload) + except ValidationError: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Could not validate credentials", + ) from None + + +def get_current_user(session: SessionDep, token: TokenDep) -> User: + """Get current user from JWT token.""" + token_data = _validate_token(token) user = session.get(User, token_data.sub) if not user: - raise HTTPException(status_code=404, detail="User not found") + raise HTTPException( + status_code=constants.NOT_FOUND_CODE, + detail="User not found", + ) if not user.is_active: - raise HTTPException(status_code=400, detail="Inactive user") + raise HTTPException( + status_code=constants.BAD_REQUEST_CODE, + detail="Inactive user", + ) return user @@ -50,8 +72,10 @@ def get_current_user(session: SessionDep, token: TokenDep) -> User: def get_current_active_superuser(current_user: CurrentUser) -> User: + """Get current active superuser.""" if not current_user.is_superuser: raise HTTPException( - status_code=403, detail="The user doesn't have enough privileges" + status_code=constants.FORBIDDEN_CODE, + detail="The user doesn't have enough privileges", ) return current_user diff --git a/backend/app/api/main.py b/backend/app/api/main.py index eac18c8e8f..62590a3ae4 100644 --- a/backend/app/api/main.py +++ b/backend/app/api/main.py @@ -1,13 +1,16 @@ +"""API router configuration.""" + from fastapi import APIRouter -from app.api.routes import items, login, private, users, utils +from app.api.routes import items, login, misc, private, users, wallets from app.core.config import settings api_router = APIRouter() api_router.include_router(login.router) api_router.include_router(users.router) -api_router.include_router(utils.router) +api_router.include_router(misc.router) api_router.include_router(items.router) +api_router.include_router(wallets.router) if settings.ENVIRONMENT == "local": diff --git a/backend/app/api/routes/items.py b/backend/app/api/routes/items.py index 177dc1e476..5681fd8f12 100644 --- a/backend/app/api/routes/items.py +++ b/backend/app/api/routes/items.py @@ -1,28 +1,31 @@ +"""Item management API endpoints.""" + import uuid -from typing import Any +# Removed unused Any import from fastapi import APIRouter, HTTPException from sqlmodel import func, select from app.api.deps import CurrentUser, SessionDep +from app.constants import BAD_REQUEST_CODE, NOT_FOUND_CODE from app.models import Item, ItemCreate, ItemPublic, ItemsPublic, ItemUpdate, Message router = APIRouter(prefix="/items", tags=["items"]) -@router.get("/", response_model=ItemsPublic) +@router.get("/") def read_items( - session: SessionDep, current_user: CurrentUser, skip: int = 0, limit: int = 100 -) -> Any: - """ - Retrieve items. - """ - + session: SessionDep, + current_user: CurrentUser, + skip: int = 0, + limit: int = 100, +) -> ItemsPublic: + """Retrieve items.""" if current_user.is_superuser: count_statement = select(func.count()).select_from(Item) count = session.exec(count_statement).one() statement = select(Item).offset(skip).limit(limit) - items = session.exec(statement).all() + item_list = session.exec(statement).all() else: count_statement = ( select(func.count()) @@ -36,74 +39,84 @@ def read_items( .offset(skip) .limit(limit) ) - items = session.exec(statement).all() + item_list = session.exec(statement).all() - return ItemsPublic(data=items, count=count) + return ItemsPublic(item_data=item_list, count=count) -@router.get("/{id}", response_model=ItemPublic) -def read_item(session: SessionDep, current_user: CurrentUser, id: uuid.UUID) -> Any: - """ - Get item by ID. - """ - item = session.get(Item, id) - if not item: - raise HTTPException(status_code=404, detail="Item not found") - if not current_user.is_superuser and (item.owner_id != current_user.id): - raise HTTPException(status_code=400, detail="Not enough permissions") - return item +@router.get("/{item_id}") +def read_item( + session: SessionDep, + current_user: CurrentUser, + item_id: uuid.UUID, +) -> ItemPublic: + """Get item by ID.""" + db_item = session.get(Item, item_id) + if not db_item: + raise HTTPException(status_code=NOT_FOUND_CODE, detail="Item not found") + if not current_user.is_superuser and (db_item.owner_id != current_user.id): + raise HTTPException( + status_code=BAD_REQUEST_CODE, + detail="Not enough permissions", + ) + return ItemPublic.model_validate(db_item) -@router.post("/", response_model=ItemPublic) +@router.post("/") def create_item( - *, session: SessionDep, current_user: CurrentUser, item_in: ItemCreate -) -> Any: - """ - Create new item. - """ - item = Item.model_validate(item_in, update={"owner_id": current_user.id}) - session.add(item) + *, + session: SessionDep, + current_user: CurrentUser, + item_in: ItemCreate, +) -> ItemPublic: + """Create new item.""" + db_item = Item.model_validate(item_in, update={"owner_id": current_user.id}) + session.add(db_item) session.commit() - session.refresh(item) - return item + session.refresh(db_item) + return ItemPublic.model_validate(db_item) -@router.put("/{id}", response_model=ItemPublic) +@router.put("/{item_id}") def update_item( *, session: SessionDep, current_user: CurrentUser, - id: uuid.UUID, + item_id: uuid.UUID, item_in: ItemUpdate, -) -> Any: - """ - Update an item. - """ - item = session.get(Item, id) - if not item: - raise HTTPException(status_code=404, detail="Item not found") - if not current_user.is_superuser and (item.owner_id != current_user.id): - raise HTTPException(status_code=400, detail="Not enough permissions") +) -> ItemPublic: + """Update an item.""" + db_item = session.get(Item, item_id) + if not db_item: + raise HTTPException(status_code=NOT_FOUND_CODE, detail="Item not found") + if not current_user.is_superuser and (db_item.owner_id != current_user.id): + raise HTTPException( + status_code=BAD_REQUEST_CODE, + detail="Not enough permissions", + ) update_dict = item_in.model_dump(exclude_unset=True) - item.sqlmodel_update(update_dict) - session.add(item) + db_item.sqlmodel_update(update_dict) + session.add(db_item) session.commit() - session.refresh(item) - return item + session.refresh(db_item) + return ItemPublic.model_validate(db_item) -@router.delete("/{id}") +@router.delete("/{item_id}") def delete_item( - session: SessionDep, current_user: CurrentUser, id: uuid.UUID + session: SessionDep, + current_user: CurrentUser, + item_id: uuid.UUID, ) -> Message: - """ - Delete an item. - """ - item = session.get(Item, id) - if not item: - raise HTTPException(status_code=404, detail="Item not found") - if not current_user.is_superuser and (item.owner_id != current_user.id): - raise HTTPException(status_code=400, detail="Not enough permissions") - session.delete(item) + """Delete an item.""" + db_item = session.get(Item, item_id) + if not db_item: + raise HTTPException(status_code=NOT_FOUND_CODE, detail="Item not found") + if not current_user.is_superuser and (db_item.owner_id != current_user.id): + raise HTTPException( + status_code=BAD_REQUEST_CODE, + detail="Not enough permissions", + ) + session.delete(db_item) session.commit() return Message(message="Item deleted successfully") diff --git a/backend/app/api/routes/login.py b/backend/app/api/routes/login.py index 980c66f86f..02e2aa471f 100644 --- a/backend/app/api/routes/login.py +++ b/backend/app/api/routes/login.py @@ -1,5 +1,7 @@ +"""Authentication API endpoints.""" + from datetime import timedelta -from typing import Annotated, Any +from typing import Annotated from fastapi import APIRouter, Depends, HTTPException from fastapi.responses import HTMLResponse @@ -7,65 +9,68 @@ from app import crud from app.api.deps import CurrentUser, SessionDep, get_current_active_superuser +from app.constants import BAD_REQUEST_CODE, NOT_FOUND_CODE from app.core import security from app.core.config import settings -from app.core.security import get_password_hash -from app.models import Message, NewPassword, Token, UserPublic -from app.utils import ( +from app.email_utils import ( generate_password_reset_token, generate_reset_password_email, send_email, verify_password_reset_token, ) +from app.models import Message, NewPassword, Token, UserPublic router = APIRouter(tags=["login"]) @router.post("/login/access-token") def login_access_token( - session: SessionDep, form_data: Annotated[OAuth2PasswordRequestForm, Depends()] + session: SessionDep, + form_data: Annotated[OAuth2PasswordRequestForm, Depends()], ) -> Token: - """ - OAuth2 compatible token login, get an access token for future requests - """ + """OAuth2 compatible token login, get an access token for future requests.""" user = crud.authenticate( - session=session, email=form_data.username, password=form_data.password + session=session, + email=form_data.username, + password=form_data.password, ) if not user: - raise HTTPException(status_code=400, detail="Incorrect email or password") - elif not user.is_active: - raise HTTPException(status_code=400, detail="Inactive user") + raise HTTPException( + status_code=BAD_REQUEST_CODE, + detail="Incorrect email or password", + ) + if not user.is_active: + raise HTTPException(status_code=BAD_REQUEST_CODE, detail="Inactive user") access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES) return Token( access_token=security.create_access_token( - user.id, expires_delta=access_token_expires - ) + str(user.id), + expires_delta=access_token_expires, + ), ) -@router.post("/login/test-token", response_model=UserPublic) -def test_token(current_user: CurrentUser) -> Any: - """ - Test access token - """ - return current_user +@router.post("/login/test-token") +def test_token(current_user: CurrentUser) -> UserPublic: + """Test access token.""" + return UserPublic.model_validate(current_user) @router.post("/password-recovery/{email}") def recover_password(email: str, session: SessionDep) -> Message: - """ - Password Recovery - """ + """Password Recovery.""" user = crud.get_user_by_email(session=session, email=email) if not user: raise HTTPException( - status_code=404, + status_code=NOT_FOUND_CODE, detail="The user with this email does not exist in the system.", ) password_reset_token = generate_password_reset_token(email=email) email_data = generate_reset_password_email( - email_to=user.email, email=email, token=password_reset_token + email_to=user.email, + email=email, + token=password_reset_token, ) send_email( email_to=user.email, @@ -77,21 +82,19 @@ def recover_password(email: str, session: SessionDep) -> Message: @router.post("/reset-password/") def reset_password(session: SessionDep, body: NewPassword) -> Message: - """ - Reset password - """ + """Reset password.""" email = verify_password_reset_token(token=body.token) if not email: - raise HTTPException(status_code=400, detail="Invalid token") + raise HTTPException(status_code=BAD_REQUEST_CODE, detail="Invalid token") user = crud.get_user_by_email(session=session, email=email) if not user: raise HTTPException( - status_code=404, + status_code=NOT_FOUND_CODE, detail="The user with this email does not exist in the system.", ) - elif not user.is_active: - raise HTTPException(status_code=400, detail="Inactive user") - hashed_password = get_password_hash(password=body.new_password) + if not user.is_active: + raise HTTPException(status_code=BAD_REQUEST_CODE, detail="Inactive user") + hashed_password = security.get_password_hash(password=body.new_password) user.hashed_password = hashed_password session.add(user) session.commit() @@ -103,22 +106,23 @@ def reset_password(session: SessionDep, body: NewPassword) -> Message: dependencies=[Depends(get_current_active_superuser)], response_class=HTMLResponse, ) -def recover_password_html_content(email: str, session: SessionDep) -> Any: - """ - HTML Content for Password Recovery - """ +def recover_password_html_content(email: str, session: SessionDep) -> HTMLResponse: + """HTML Content for Password Recovery.""" user = crud.get_user_by_email(session=session, email=email) if not user: raise HTTPException( - status_code=404, + status_code=NOT_FOUND_CODE, detail="The user with this username does not exist in the system.", ) password_reset_token = generate_password_reset_token(email=email) email_data = generate_reset_password_email( - email_to=user.email, email=email, token=password_reset_token + email_to=user.email, + email=email, + token=password_reset_token, ) return HTMLResponse( - content=email_data.html_content, headers={"subject:": email_data.subject} + content=email_data.html_content, + headers={"subject:": email_data.subject}, ) diff --git a/backend/app/api/routes/utils.py b/backend/app/api/routes/misc.py similarity index 75% rename from backend/app/api/routes/utils.py rename to backend/app/api/routes/misc.py index fc093419b3..c17f67bdf1 100644 --- a/backend/app/api/routes/utils.py +++ b/backend/app/api/routes/misc.py @@ -1,9 +1,12 @@ +"""Utility API endpoints.""" + from fastapi import APIRouter, Depends from pydantic.networks import EmailStr from app.api.deps import get_current_active_superuser +from app.constants import CREATED_CODE +from app.email_utils import generate_test_email, send_email from app.models import Message -from app.utils import generate_test_email, send_email router = APIRouter(prefix="/utils", tags=["utils"]) @@ -11,12 +14,10 @@ @router.post( "/test-email/", dependencies=[Depends(get_current_active_superuser)], - status_code=201, + status_code=CREATED_CODE, ) def test_email(email_to: EmailStr) -> Message: - """ - Test emails. - """ + """Test emails.""" email_data = generate_test_email(email_to=email_to) send_email( email_to=email_to, @@ -28,4 +29,5 @@ def test_email(email_to: EmailStr) -> Message: @router.get("/health-check/") async def health_check() -> bool: + """Health check endpoint.""" return True diff --git a/backend/app/api/routes/private.py b/backend/app/api/routes/private.py index 9f33ef1900..cb68282383 100644 --- a/backend/app/api/routes/private.py +++ b/backend/app/api/routes/private.py @@ -1,4 +1,6 @@ -from typing import Any +"""Private API endpoints.""" + +# Removed unused Any import from fastapi import APIRouter from pydantic import BaseModel @@ -13,19 +15,18 @@ router = APIRouter(tags=["private"], prefix="/private") -class PrivateUserCreate(BaseModel): +class PrivateUserCreate(BaseModel): # type: ignore[explicit-any] + """Private user creation model.""" + email: str password: str full_name: str is_verified: bool = False -@router.post("/users/", response_model=UserPublic) -def create_user(user_in: PrivateUserCreate, session: SessionDep) -> Any: - """ - Create a new user. - """ - +@router.post("/users/") +def create_user(user_in: PrivateUserCreate, session: SessionDep) -> UserPublic: + """Create a new user.""" user = User( email=user_in.email, full_name=user_in.full_name, @@ -35,4 +36,4 @@ def create_user(user_in: PrivateUserCreate, session: SessionDep) -> Any: session.add(user) session.commit() - return user + return UserPublic.model_validate(user) diff --git a/backend/app/api/routes/users.py b/backend/app/api/routes/users.py index 6429818458..f644a570d8 100644 --- a/backend/app/api/routes/users.py +++ b/backend/app/api/routes/users.py @@ -1,30 +1,24 @@ +"""models.User management API endpoints.""" + import uuid -from typing import Any from fastapi import APIRouter, Depends, HTTPException from sqlmodel import col, delete, func, select -from app import crud +from app import crud, models from app.api.deps import ( - CurrentUser, SessionDep, get_current_active_superuser, ) +from app.constants import ( + BAD_REQUEST_CODE, + CONFLICT_CODE, + FORBIDDEN_CODE, + NOT_FOUND_CODE, +) from app.core.config import settings from app.core.security import get_password_hash, verify_password -from app.models import ( - Item, - Message, - UpdatePassword, - User, - UserCreate, - UserPublic, - UserRegister, - UsersPublic, - UserUpdate, - UserUpdateMe, -) -from app.utils import generate_new_account_email, send_email +from app.email_utils import generate_new_account_email, send_email router = APIRouter(prefix="/users", tags=["users"]) @@ -32,195 +26,204 @@ @router.get( "/", dependencies=[Depends(get_current_active_superuser)], - response_model=UsersPublic, ) -def read_users(session: SessionDep, skip: int = 0, limit: int = 100) -> Any: - """ - Retrieve users. - """ - - count_statement = select(func.count()).select_from(User) +def read_users( + session: SessionDep, + skip: int = 0, + limit: int = 100, +) -> models.UsersPublic: + """Retrieve users.""" + count_statement = select(func.count()).select_from(models.User) count = session.exec(count_statement).one() - statement = select(User).offset(skip).limit(limit) + statement = select(models.User).offset(skip).limit(limit) users = session.exec(statement).all() - return UsersPublic(data=users, count=count) + return models.UsersPublic(user_data=users, count=count) @router.post( - "/", dependencies=[Depends(get_current_active_superuser)], response_model=UserPublic + "/", + dependencies=[Depends(get_current_active_superuser)], ) -def create_user(*, session: SessionDep, user_in: UserCreate) -> Any: - """ - Create new user. - """ +def create_user( + *, + session: SessionDep, + user_in: models.UserCreate, +) -> models.UserPublic: + """Create new user.""" user = crud.get_user_by_email(session=session, email=user_in.email) if user: raise HTTPException( - status_code=400, + status_code=BAD_REQUEST_CODE, detail="The user with this email already exists in the system.", ) user = crud.create_user(session=session, user_create=user_in) - if settings.emails_enabled and user_in.email: + if not settings.emails_enabled and user_in.email: email_data = generate_new_account_email( - email_to=user_in.email, username=user_in.email, password=user_in.password + email_to=user_in.email, + username=user_in.email, + password=user_in.password, ) send_email( email_to=user_in.email, subject=email_data.subject, html_content=email_data.html_content, ) - return user + return models.UserPublic.model_validate(user) -@router.patch("/me", response_model=UserPublic) +@router.patch("/me") def update_user_me( - *, session: SessionDep, user_in: UserUpdateMe, current_user: CurrentUser -) -> Any: - """ - Update own user. - """ - + *, + session: SessionDep, + user_in: models.UserUpdateMe, + current_user: models.User, +) -> models.UserPublic: + """Update own user.""" if user_in.email: existing_user = crud.get_user_by_email(session=session, email=user_in.email) if existing_user and existing_user.id != current_user.id: raise HTTPException( - status_code=409, detail="User with this email already exists" + status_code=CONFLICT_CODE, + detail="models.User with this email already exists", ) user_data = user_in.model_dump(exclude_unset=True) current_user.sqlmodel_update(user_data) session.add(current_user) session.commit() session.refresh(current_user) - return current_user + return models.UserPublic.model_validate(current_user) -@router.patch("/me/password", response_model=Message) +@router.patch("/me/password") def update_password_me( - *, session: SessionDep, body: UpdatePassword, current_user: CurrentUser -) -> Any: - """ - Update own password. - """ + *, + session: SessionDep, + body: models.UpdatePassword, + current_user: models.User, +) -> models.Message: + """Update own password.""" if not verify_password(body.current_password, current_user.hashed_password): - raise HTTPException(status_code=400, detail="Incorrect password") + raise HTTPException(status_code=BAD_REQUEST_CODE, detail="Incorrect password") if body.current_password == body.new_password: raise HTTPException( - status_code=400, detail="New password cannot be the same as the current one" + status_code=BAD_REQUEST_CODE, + detail="New password cannot be the same as the current one", ) hashed_password = get_password_hash(body.new_password) current_user.hashed_password = hashed_password session.add(current_user) session.commit() - return Message(message="Password updated successfully") + return models.Message(message="Password updated successfully") -@router.get("/me", response_model=UserPublic) -def read_user_me(current_user: CurrentUser) -> Any: - """ - Get current user. - """ - return current_user +@router.get("/me") +def read_user_me(current_user: models.User) -> models.UserPublic: + """Get current user.""" + return models.UserPublic.model_validate(current_user) -@router.delete("/me", response_model=Message) -def delete_user_me(session: SessionDep, current_user: CurrentUser) -> Any: - """ - Delete own user. - """ +@router.delete("/me") +def delete_user_me( + session: SessionDep, + current_user: models.User, +) -> models.Message: + """Delete own user.""" if current_user.is_superuser: raise HTTPException( - status_code=403, detail="Super users are not allowed to delete themselves" + status_code=FORBIDDEN_CODE, + detail="Super users are not allowed to delete themselves", ) session.delete(current_user) session.commit() - return Message(message="User deleted successfully") + return models.Message(message="models.User deleted successfully") -@router.post("/signup", response_model=UserPublic) -def register_user(session: SessionDep, user_in: UserRegister) -> Any: - """ - Create new user without the need to be logged in. - """ +@router.post("/signup") +def register_user( + session: SessionDep, + user_in: models.UserRegister, +) -> models.UserPublic: + """Create new user without the need to be logged in.""" user = crud.get_user_by_email(session=session, email=user_in.email) if user: raise HTTPException( - status_code=400, + status_code=BAD_REQUEST_CODE, detail="The user with this email already exists in the system", ) - user_create = UserCreate.model_validate(user_in) + user_create = models.UserCreate.model_validate(user_in) user = crud.create_user(session=session, user_create=user_create) - return user + return models.UserPublic.model_validate(user) -@router.get("/{user_id}", response_model=UserPublic) +@router.get("/{user_id}") def read_user_by_id( - user_id: uuid.UUID, session: SessionDep, current_user: CurrentUser -) -> Any: - """ - Get a specific user by id. - """ - user = session.get(User, user_id) + user_id: uuid.UUID, + session: SessionDep, + current_user: models.User, +) -> models.UserPublic: + """Get a specific user by id.""" + user = session.get(models.User, user_id) + if not user: + raise HTTPException(status_code=NOT_FOUND_CODE, detail="models.User not found") if user == current_user: - return user + return models.UserPublic.model_validate(user) if not current_user.is_superuser: raise HTTPException( - status_code=403, + status_code=FORBIDDEN_CODE, detail="The user doesn't have enough privileges", ) - return user + return models.UserPublic.model_validate(user) @router.patch( "/{user_id}", dependencies=[Depends(get_current_active_superuser)], - response_model=UserPublic, ) def update_user( *, session: SessionDep, user_id: uuid.UUID, - user_in: UserUpdate, -) -> Any: - """ - Update a user. - """ - - db_user = session.get(User, user_id) + user_in: models.UserUpdate, +) -> models.UserPublic: + """Update a user.""" + db_user = session.get(models.User, user_id) if not db_user: raise HTTPException( - status_code=404, + status_code=NOT_FOUND_CODE, detail="The user with this id does not exist in the system", ) if user_in.email: existing_user = crud.get_user_by_email(session=session, email=user_in.email) if existing_user and existing_user.id != user_id: raise HTTPException( - status_code=409, detail="User with this email already exists" + status_code=CONFLICT_CODE, + detail="models.User with this email already exists", ) db_user = crud.update_user(session=session, db_user=db_user, user_in=user_in) - return db_user + return models.UserPublic.model_validate(db_user) @router.delete("/{user_id}", dependencies=[Depends(get_current_active_superuser)]) def delete_user( - session: SessionDep, current_user: CurrentUser, user_id: uuid.UUID -) -> Message: - """ - Delete a user. - """ - user = session.get(User, user_id) + session: SessionDep, + current_user: models.User, + user_id: uuid.UUID, +) -> models.Message: + """Delete a user.""" + user = session.get(models.User, user_id) if not user: - raise HTTPException(status_code=404, detail="User not found") + raise HTTPException(status_code=NOT_FOUND_CODE, detail="models.User not found") if user == current_user: raise HTTPException( - status_code=403, detail="Super users are not allowed to delete themselves" + status_code=FORBIDDEN_CODE, + detail="Super users are not allowed to delete themselves", ) - statement = delete(Item).where(col(Item.owner_id) == user_id) - session.exec(statement) # type: ignore + statement = delete(models.Item).where(col(models.Item.owner_id) == user_id) # noqa: WPS221 + session.execute(statement) # type: ignore[deprecated] session.delete(user) session.commit() - return Message(message="User deleted successfully") + return models.Message(message="models.User deleted successfully") diff --git a/backend/app/api/routes/wallets.py b/backend/app/api/routes/wallets.py new file mode 100644 index 0000000000..140ad14d83 --- /dev/null +++ b/backend/app/api/routes/wallets.py @@ -0,0 +1,148 @@ +"""Wallet management API endpoints.""" + +import uuid + +from fastapi import APIRouter, HTTPException +from sqlmodel import func, select + +from app.api.deps import CurrentUser, SessionDep +from app.constants import BAD_REQUEST_CODE, NOT_FOUND_CODE +from app.crud import ( + create_transaction, + create_wallet, + get_user_wallets, + get_wallet_by_id, + get_wallet_transactions, +) +from app.models import ( + Transaction, + TransactionCreate, + TransactionPublic, + TransactionsPublic, + WalletCreate, + WalletPublic, + WalletsPublic, +) + +router = APIRouter(prefix="/wallets", tags=["wallets"]) + + +@router.post("/") +def create_user_wallet( + *, + session: SessionDep, + current_user: CurrentUser, + wallet_in: WalletCreate, +) -> WalletPublic: + """Create new wallet for the current user.""" + try: + db_wallet = create_wallet( + session=session, + wallet_in=wallet_in, + user_id=current_user.id, + ) + return WalletPublic.model_validate(db_wallet) + except ValueError as e: + raise HTTPException(status_code=BAD_REQUEST_CODE, detail=str(e)) from e + + +@router.get("/") +def read_user_wallets( + session: SessionDep, + current_user: CurrentUser, +) -> WalletsPublic: + """Retrieve current user's wallets.""" + wallets = get_user_wallets(session=session, user_id=current_user.id) + wallet_publics = [WalletPublic.model_validate(wallet) for wallet in wallets] + return WalletsPublic(wallet_data=wallet_publics, count=len(wallet_publics)) + + +@router.get("/{wallet_id}") +def read_wallet( + session: SessionDep, + current_user: CurrentUser, + wallet_id: uuid.UUID, +) -> WalletPublic: + """Get wallet by ID.""" + db_wallet = get_wallet_by_id(session=session, wallet_id=wallet_id) + if not db_wallet: + raise HTTPException(status_code=NOT_FOUND_CODE, detail="Wallet not found") + + # Check ownership + if db_wallet.user_id != current_user.id: + raise HTTPException( + status_code=BAD_REQUEST_CODE, + detail="Not enough permissions", + ) + + return WalletPublic.model_validate(db_wallet) + + +@router.post("/{wallet_id}/transactions/") +def create_wallet_transaction( + *, + session: SessionDep, + current_user: CurrentUser, + wallet_id: uuid.UUID, + transaction_in: TransactionCreate, +) -> TransactionPublic: + """Create new transaction for a wallet.""" + # Check wallet exists and belongs to user + db_wallet = get_wallet_by_id(session=session, wallet_id=wallet_id) + if not db_wallet: + raise HTTPException(status_code=NOT_FOUND_CODE, detail="Wallet not found") + + if db_wallet.user_id != current_user.id: + raise HTTPException( + status_code=BAD_REQUEST_CODE, + detail="Not enough permissions", + ) + + try: + db_transaction = create_transaction( + session=session, + transaction_in=transaction_in, + wallet_id=wallet_id, + ) + return TransactionPublic.model_validate(db_transaction) + except ValueError as e: + raise HTTPException(status_code=BAD_REQUEST_CODE, detail=str(e)) from e + + +@router.get("/{wallet_id}/transactions/") +def read_wallet_transactions( + session: SessionDep, + current_user: CurrentUser, + wallet_id: uuid.UUID, + skip: int = 0, + limit: int = 100, +) -> TransactionsPublic: + """Get transactions for a wallet.""" + # Check wallet exists and belongs to user + db_wallet = get_wallet_by_id(session=session, wallet_id=wallet_id) + if not db_wallet: + raise HTTPException(status_code=NOT_FOUND_CODE, detail="Wallet not found") + + if db_wallet.user_id != current_user.id: + raise HTTPException( + status_code=BAD_REQUEST_CODE, + detail="Not enough permissions", + ) + + transactions = get_wallet_transactions( + session=session, + wallet_id=wallet_id, + skip=skip, + limit=limit, + ) + + # Get total count for pagination + count_statement = ( + select(func.count()) + .select_from(Transaction) + .where(Transaction.wallet_id == wallet_id) + ) + count = session.exec(count_statement).one() + + transaction_publics = [TransactionPublic.model_validate(tx) for tx in transactions] + return TransactionsPublic(transaction_data=transaction_publics, count=count) diff --git a/backend/app/backend_pre_start.py b/backend/app/backend_pre_start.py index c2f8e29ae1..f16583215b 100644 --- a/backend/app/backend_pre_start.py +++ b/backend/app/backend_pre_start.py @@ -1,3 +1,5 @@ +"""Backend pre-start script to ensure database connectivity.""" + import logging from sqlalchemy import Engine @@ -17,19 +19,21 @@ stop=stop_after_attempt(max_tries), wait=wait_fixed(wait_seconds), before=before_log(logger, logging.INFO), - after=after_log(logger, logging.WARN), + after=after_log(logger, logging.WARNING), ) def init(db_engine: Engine) -> None: + """Initialize database connection with retry logic.""" try: with Session(db_engine) as session: # Try to create session to check if DB is awake session.exec(select(1)) - except Exception as e: - logger.error(e) - raise e + except Exception: + logger.exception("Database connection failed") + raise def main() -> None: + """Initialize database connectivity check.""" logger.info("Initializing service") init(engine) logger.info("Service finished initializing") diff --git a/backend/app/constants.py b/backend/app/constants.py new file mode 100644 index 0000000000..0dc1a51558 --- /dev/null +++ b/backend/app/constants.py @@ -0,0 +1,27 @@ +"""Application constants.""" + +# HTTP Status codes +OK_CODE = 200 +CREATED_CODE = 201 +BAD_REQUEST_CODE = 400 +FORBIDDEN_CODE = 403 +NOT_FOUND_CODE = 404 +CONFLICT_CODE = 409 + +# String field lengths +EMAIL_MAX_LENGTH = 255 +STRING_MAX_LENGTH = 255 +PASSWORD_MIN_LENGTH = 8 +PASSWORD_MAX_LENGTH = 40 +TOKEN_LENGTH = 32 + +# Database limits +MAX_MODULE_MEMBERS = 7 +MAX_FUNCTION_VARIABLES = 5 +MAX_ASSERT_STATEMENTS = 5 +MAX_TRY_BODY_LENGTH = 1 +MAX_IMPORTED_NAMES = 8 +MIN_VARIABLE_NAME_LENGTH = 2 +MAX_JONES_COMPLEXITY = 14 +MAX_STRING_LITERAL_USAGE = 3 +MAX_EXPRESSION_USAGE = 7 diff --git a/backend/app/core/config.py b/backend/app/core/config.py index c78e173617..41b95b8fd7 100644 --- a/backend/app/core/config.py +++ b/backend/app/core/config.py @@ -1,6 +1,8 @@ +"""Application configuration settings.""" + import secrets import warnings -from typing import Annotated, Any, Literal +from typing import Annotated, Literal, Self from pydantic import ( AnyUrl, @@ -12,62 +14,57 @@ model_validator, ) from pydantic_settings import BaseSettings, SettingsConfigDict -from typing_extensions import Self + +from app.constants import TOKEN_LENGTH -def parse_cors(v: Any) -> list[str] | str: - if isinstance(v, str) and not v.startswith("["): - return [i.strip() for i in v.split(",")] - elif isinstance(v, list | str): - return v - raise ValueError(v) +def parse_cors(cors_value: str | list[str]) -> list[str] | str: + """Parse CORS configuration from string or list.""" + if isinstance(cors_value, str) and not cors_value.startswith("["): + return [cors_item.strip() for cors_item in cors_value.split(",")] + if isinstance(cors_value, (list, str)): + return cors_value + raise ValueError(cors_value) -class Settings(BaseSettings): +class Settings(BaseSettings): # type: ignore[explicit-any] + """Application settings configuration.""" + + # Configuration model_config = SettingsConfigDict( # Use top level .env file (one level above ./backend/) env_file="../.env", env_ignore_empty=True, extra="ignore", ) + + # API Settings API_V1_STR: str = "/api/v1" - SECRET_KEY: str = secrets.token_urlsafe(32) - # 60 minutes * 24 hours * 8 days = 8 days - ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8 + SECRET_KEY: str = secrets.token_urlsafe(TOKEN_LENGTH) + ACCESS_TOKEN_EXPIRE_MINUTES: int = ( + 60 * 24 * 8 + ) # 60 minutes * 24 hours * 8 days = 8 days FRONTEND_HOST: str = "http://localhost:5173" ENVIRONMENT: Literal["local", "staging", "production"] = "local" + # CORS Settings BACKEND_CORS_ORIGINS: Annotated[ - list[AnyUrl] | str, BeforeValidator(parse_cors) + list[AnyUrl] | str, + BeforeValidator(parse_cors), ] = [] - @computed_field # type: ignore[prop-decorator] - @property - def all_cors_origins(self) -> list[str]: - return [str(origin).rstrip("/") for origin in self.BACKEND_CORS_ORIGINS] + [ - self.FRONTEND_HOST - ] - + # Project Settings PROJECT_NAME: str SENTRY_DSN: HttpUrl | None = None + + # Database Settings POSTGRES_SERVER: str POSTGRES_PORT: int = 5432 POSTGRES_USER: str POSTGRES_PASSWORD: str = "" POSTGRES_DB: str = "" - @computed_field # type: ignore[prop-decorator] - @property - def SQLALCHEMY_DATABASE_URI(self) -> PostgresDsn: - return PostgresDsn.build( - scheme="postgresql+psycopg", - username=self.POSTGRES_USER, - password=self.POSTGRES_PASSWORD, - host=self.POSTGRES_SERVER, - port=self.POSTGRES_PORT, - path=self.POSTGRES_DB, - ) - + # Email Settings SMTP_TLS: bool = True SMTP_SSL: bool = False SMTP_PORT: int = 587 @@ -76,26 +73,42 @@ def SQLALCHEMY_DATABASE_URI(self) -> PostgresDsn: SMTP_PASSWORD: str | None = None EMAILS_FROM_EMAIL: EmailStr | None = None EMAILS_FROM_NAME: EmailStr | None = None + EMAIL_RESET_TOKEN_EXPIRE_HOURS: int = 48 - @model_validator(mode="after") - def _set_default_emails_from(self) -> Self: - if not self.EMAILS_FROM_NAME: - self.EMAILS_FROM_NAME = self.PROJECT_NAME - return self + # Test Settings + EMAIL_TEST_USER: EmailStr = "test@example.com" + FIRST_SUPERUSER: EmailStr + FIRST_SUPERUSER_PASSWORD: str - EMAIL_RESET_TOKEN_EXPIRE_HOURS: int = 48 + @property + @computed_field + def all_cors_origins(self) -> list[str]: + """Get all CORS origins.""" + return [str(origin).rstrip("/") for origin in self.BACKEND_CORS_ORIGINS] + [ + self.FRONTEND_HOST, + ] + + @property + @computed_field + def SQLALCHEMY_DATABASE_URI(self) -> PostgresDsn: # noqa: N802 + """Build database URI from configuration.""" + return PostgresDsn.build( + scheme="postgresql+psycopg", + username=self.POSTGRES_USER, + password=self.POSTGRES_PASSWORD, + host=self.POSTGRES_SERVER, + port=self.POSTGRES_PORT, + path=self.POSTGRES_DB, + ) - @computed_field # type: ignore[prop-decorator] @property + @computed_field def emails_enabled(self) -> bool: + """Check if email configuration is enabled.""" return bool(self.SMTP_HOST and self.EMAILS_FROM_EMAIL) - EMAIL_TEST_USER: EmailStr = "test@example.com" - FIRST_SUPERUSER: EmailStr - FIRST_SUPERUSER_PASSWORD: str - - def _check_default_secret(self, var_name: str, value: str | None) -> None: - if value == "changethis": + def _check_default_secret(self, var_name: str, secret_value: str | None) -> None: + if secret_value == "changethis": # noqa: S105 message = ( f'The value of {var_name} is "changethis", ' "for security, please change it, at least for deployments." @@ -105,15 +118,22 @@ def _check_default_secret(self, var_name: str, value: str | None) -> None: else: raise ValueError(message) + @model_validator(mode="after") + def _set_default_emails_from(self) -> Self: + if not self.EMAILS_FROM_NAME: + self.EMAILS_FROM_NAME = self.PROJECT_NAME # noqa: WPS601 + return self + @model_validator(mode="after") def _enforce_non_default_secrets(self) -> Self: self._check_default_secret("SECRET_KEY", self.SECRET_KEY) self._check_default_secret("POSTGRES_PASSWORD", self.POSTGRES_PASSWORD) self._check_default_secret( - "FIRST_SUPERUSER_PASSWORD", self.FIRST_SUPERUSER_PASSWORD + "FIRST_SUPERUSER_PASSWORD", + self.FIRST_SUPERUSER_PASSWORD, ) return self -settings = Settings() # type: ignore +settings = Settings() # type: ignore[call-arg] diff --git a/backend/app/core/db.py b/backend/app/core/db.py index ba991fb36d..6892433bcb 100644 --- a/backend/app/core/db.py +++ b/backend/app/core/db.py @@ -1,3 +1,5 @@ +"""Database configuration and initialization.""" + from sqlmodel import Session, create_engine, select from app import crud @@ -13,16 +15,9 @@ def init_db(session: Session) -> None: - # Tables should be created with Alembic migrations - # But if you don't want to use migrations, create - # the tables un-commenting the next lines - # from sqlmodel import SQLModel - - # This works because the models are already imported and registered from app.models - # SQLModel.metadata.create_all(engine) - + """Initialize database with default data.""" user = session.exec( - select(User).where(User.email == settings.FIRST_SUPERUSER) + select(User).where(User.email == settings.FIRST_SUPERUSER), ).first() if not user: user_in = UserCreate( diff --git a/backend/app/core/security.py b/backend/app/core/security.py index 7aff7cfb32..075383af55 100644 --- a/backend/app/core/security.py +++ b/backend/app/core/security.py @@ -1,6 +1,8 @@ -from datetime import datetime, timedelta, timezone -from typing import Any +"""Security utilities for authentication and passwords.""" +from datetime import UTC, datetime, timedelta + +# Removed unused Any import import jwt from passlib.context import CryptContext @@ -12,16 +14,18 @@ ALGORITHM = "HS256" -def create_access_token(subject: str | Any, expires_delta: timedelta) -> str: - expire = datetime.now(timezone.utc) + expires_delta +def create_access_token(subject: str, expires_delta: timedelta) -> str: + """Create JWT access token.""" + expire = datetime.now(UTC) + expires_delta to_encode = {"exp": expire, "sub": str(subject)} - encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=ALGORITHM) - return encoded_jwt + return jwt.encode(to_encode, settings.SECRET_KEY, algorithm=ALGORITHM) def verify_password(plain_password: str, hashed_password: str) -> bool: + """Verify password against hash.""" return pwd_context.verify(plain_password, hashed_password) def get_password_hash(password: str) -> str: + """Generate password hash.""" return pwd_context.hash(password) diff --git a/backend/app/crud.py b/backend/app/crud.py index 905bf48724..e5f9f0acbe 100644 --- a/backend/app/crud.py +++ b/backend/app/crud.py @@ -1,15 +1,31 @@ +"""CRUD operations for database models.""" + import uuid -from typing import Any +from decimal import Decimal -from sqlmodel import Session, select +from sqlmodel import Session, desc, select from app.core.security import get_password_hash, verify_password -from app.models import Item, ItemCreate, User, UserCreate, UserUpdate +from app.models import ( + CurrencyType, + Item, + ItemCreate, + Transaction, + TransactionCreate, + TransactionType, + User, + UserCreate, + UserUpdate, + Wallet, + WalletCreate, +) def create_user(*, session: Session, user_create: UserCreate) -> User: + """Create a new user.""" db_obj = User.model_validate( - user_create, update={"hashed_password": get_password_hash(user_create.password)} + user_create, + update={"hashed_password": get_password_hash(user_create.password)}, ) session.add(db_obj) session.commit() @@ -17,11 +33,11 @@ def create_user(*, session: Session, user_create: UserCreate) -> User: return db_obj -def update_user(*, session: Session, db_user: User, user_in: UserUpdate) -> Any: +def update_user(*, session: Session, db_user: User, user_in: UserUpdate) -> User: + """Update an existing user.""" user_data = user_in.model_dump(exclude_unset=True) extra_data = {} - if "password" in user_data: - password = user_data["password"] + if password := user_data.get("password"): hashed_password = get_password_hash(password) extra_data["hashed_password"] = hashed_password db_user.sqlmodel_update(user_data, update=extra_data) @@ -32,12 +48,13 @@ def update_user(*, session: Session, db_user: User, user_in: UserUpdate) -> Any: def get_user_by_email(*, session: Session, email: str) -> User | None: + """Get user by email address.""" statement = select(User).where(User.email == email) - session_user = session.exec(statement).first() - return session_user + return session.exec(statement).first() def authenticate(*, session: Session, email: str, password: str) -> User | None: + """Authenticate user with email and password.""" db_user = get_user_by_email(session=session, email=email) if not db_user: return None @@ -47,8 +64,151 @@ def authenticate(*, session: Session, email: str, password: str) -> User | None: def create_item(*, session: Session, item_in: ItemCreate, owner_id: uuid.UUID) -> Item: + """Create a new item.""" db_item = Item.model_validate(item_in, update={"owner_id": owner_id}) session.add(db_item) session.commit() session.refresh(db_item) return db_item + + +# Exchange rates for currency conversion (hardcoded as per requirements) +EXCHANGE_RATES = { + (CurrencyType.USD, CurrencyType.EUR): Decimal("0.85"), + (CurrencyType.EUR, CurrencyType.USD): Decimal("1.18"), + (CurrencyType.USD, CurrencyType.RUB): Decimal("75.0"), + (CurrencyType.RUB, CurrencyType.USD): Decimal("0.013"), + (CurrencyType.EUR, CurrencyType.RUB): Decimal("88.0"), + (CurrencyType.RUB, CurrencyType.EUR): Decimal("0.011"), +} + +# Transaction fee percentage +TRANSACTION_FEE_RATE = Decimal("0.02") # 2% fee for cross-currency transactions + +# Wallet constraints +MAX_WALLETS_PER_USER = 3 + +# Error messages +WALLET_LIMIT_EXCEEDED = "User cannot have more than 3 wallets" +WALLET_NOT_FOUND = "Wallet not found" +INSUFFICIENT_BALANCE = "Insufficient balance for debit transaction" + + +def create_wallet( + *, + session: Session, + wallet_in: WalletCreate, + user_id: uuid.UUID, +) -> Wallet: + """Create a new wallet for a user.""" + # Check if user already has 3 wallets + existing_wallets = session.exec( + select(Wallet).where(Wallet.user_id == user_id), + ).all() + + if len(existing_wallets) >= MAX_WALLETS_PER_USER: + raise ValueError(WALLET_LIMIT_EXCEEDED) + + # Check if user already has a wallet with this currency + for wallet in existing_wallets: + if wallet.currency == wallet_in.currency: + msg = f"User already has a {wallet_in.currency} wallet" + raise ValueError(msg) + + db_wallet = Wallet.model_validate( + wallet_in, + update={"user_id": user_id, "balance": Decimal("0.00")}, + ) + session.add(db_wallet) + session.commit() + session.refresh(db_wallet) + return db_wallet + + +def get_wallet_by_id(*, session: Session, wallet_id: uuid.UUID) -> Wallet | None: + """Get wallet by ID.""" + return session.get(Wallet, wallet_id) + + +def get_user_wallets(*, session: Session, user_id: uuid.UUID) -> list[Wallet]: + """Get all wallets for a user.""" + statement = select(Wallet).where(Wallet.user_id == user_id) + return list(session.exec(statement).all()) + + +def create_transaction( + *, + session: Session, + transaction_in: TransactionCreate, + wallet_id: uuid.UUID, +) -> Transaction: + """Create a new transaction for a wallet.""" + # Get the wallet + wallet = get_wallet_by_id(session=session, wallet_id=wallet_id) + if not wallet: + raise ValueError(WALLET_NOT_FOUND) + + # Determine transaction currency (default to wallet currency if not specified) + transaction_currency = transaction_in.currency or wallet.currency + amount = transaction_in.amount + + # Handle currency conversion and fees if needed + if transaction_currency != wallet.currency: + if (transaction_currency, wallet.currency) not in EXCHANGE_RATES: + msg = ( + f"Currency conversion from {transaction_currency} " + f"to {wallet.currency} not supported" + ) + raise ValueError(msg) + + # Convert amount to wallet currency + rate = EXCHANGE_RATES[(transaction_currency, wallet.currency)] + amount = amount * rate + + # Apply transaction fee + fee = amount * TRANSACTION_FEE_RATE + amount = amount - fee + + # Check balance for debit transactions + if transaction_in.transaction_type == TransactionType.DEBIT: + if wallet.balance < amount: + raise ValueError(INSUFFICIENT_BALANCE) + new_balance = wallet.balance - amount + else: # Credit transaction + new_balance = wallet.balance + amount + + # Update wallet balance + wallet.balance = new_balance.quantize(Decimal("0.01")) + session.add(wallet) + + # Create transaction record + db_transaction = Transaction.model_validate( + transaction_in, + update={ + "wallet_id": wallet_id, + "amount": amount.quantize(Decimal("0.01")), + "currency": transaction_currency, + }, + ) + session.add(db_transaction) + session.commit() + session.refresh(db_transaction) + return db_transaction + + +def get_wallet_transactions( + *, + session: Session, + wallet_id: uuid.UUID, + skip: int = 0, + limit: int = 100, +) -> list[Transaction]: + """Get transactions for a wallet.""" + statement = ( + select(Transaction) + .where(Transaction.wallet_id == wallet_id) + .order_by(desc(Transaction.timestamp)) + .offset(skip) + .limit(limit) + ) + return list(session.exec(statement).all()) diff --git a/backend/app/utils.py b/backend/app/email_utils.py similarity index 75% rename from backend/app/utils.py rename to backend/app/email_utils.py index ac029f6342..531f274ebc 100644 --- a/backend/app/utils.py +++ b/backend/app/email_utils.py @@ -1,10 +1,12 @@ +"""Utility functions for email, authentication, and template rendering.""" + import logging from dataclasses import dataclass -from datetime import datetime, timedelta, timezone +from datetime import UTC, datetime, timedelta from pathlib import Path -from typing import Any -import emails # type: ignore +# Removed unused Any import +import emails # type: ignore[import-not-found] import jwt from jinja2 import Template from jwt.exceptions import InvalidTokenError @@ -18,16 +20,18 @@ @dataclass class EmailData: + """Data structure for email content and metadata.""" + html_content: str subject: str -def render_email_template(*, template_name: str, context: dict[str, Any]) -> str: +def render_email_template(*, template_name: str, context: dict[str, str | int]) -> str: + """Render email template with provided context.""" template_str = ( Path(__file__).parent / "email-templates" / "build" / template_name ).read_text() - html_content = Template(template_str).render(context) - return html_content + return Template(template_str).render(context) def send_email( @@ -36,7 +40,10 @@ def send_email( subject: str = "", html_content: str = "", ) -> None: - assert settings.emails_enabled, "no provided configuration for email variables" + """Send email to specified recipient.""" + if not settings.emails_enabled: + msg = "no provided configuration for email variables" + raise ValueError(msg) message = emails.Message( subject=subject, html=html_content, @@ -52,10 +59,11 @@ def send_email( if settings.SMTP_PASSWORD: smtp_options["password"] = settings.SMTP_PASSWORD response = message.send(to=email_to, smtp=smtp_options) - logger.info(f"send email result: {response}") + logger.info("send email result: %s", response) def generate_test_email(email_to: str) -> EmailData: + """Generate test email data.""" project_name = settings.PROJECT_NAME subject = f"{project_name} - Test email" html_content = render_email_template( @@ -66,6 +74,7 @@ def generate_test_email(email_to: str) -> EmailData: def generate_reset_password_email(email_to: str, email: str, token: str) -> EmailData: + """Generate password reset email data.""" project_name = settings.PROJECT_NAME subject = f"{project_name} - Password recovery for user {email}" link = f"{settings.FRONTEND_HOST}/reset-password?token={token}" @@ -83,8 +92,11 @@ def generate_reset_password_email(email_to: str, email: str, token: str) -> Emai def generate_new_account_email( - email_to: str, username: str, password: str + email_to: str, + username: str, + password: str, ) -> EmailData: + """Generate new account confirmation email data.""" project_name = settings.PROJECT_NAME subject = f"{project_name} - New account for user {username}" html_content = render_email_template( @@ -101,23 +113,26 @@ def generate_new_account_email( def generate_password_reset_token(email: str) -> str: + """Generate JWT token for password reset.""" delta = timedelta(hours=settings.EMAIL_RESET_TOKEN_EXPIRE_HOURS) - now = datetime.now(timezone.utc) + now = datetime.now(UTC) expires = now + delta exp = expires.timestamp() - encoded_jwt = jwt.encode( + return jwt.encode( {"exp": exp, "nbf": now, "sub": email}, settings.SECRET_KEY, algorithm=security.ALGORITHM, ) - return encoded_jwt def verify_password_reset_token(token: str) -> str | None: + """Verify and decode password reset JWT token.""" try: decoded_token = jwt.decode( - token, settings.SECRET_KEY, algorithms=[security.ALGORITHM] + token, + settings.SECRET_KEY, + algorithms=[security.ALGORITHM], ) - return str(decoded_token["sub"]) except InvalidTokenError: return None + return str(decoded_token["sub"]) diff --git a/backend/app/initial_data.py b/backend/app/initial_data.py index d806c3d381..acb2f6111b 100644 --- a/backend/app/initial_data.py +++ b/backend/app/initial_data.py @@ -1,3 +1,5 @@ +"""Initial data creation script.""" + import logging from sqlmodel import Session @@ -9,11 +11,13 @@ def init() -> None: + """Initialize database with initial data.""" with Session(engine) as session: init_db(session) def main() -> None: + """Run initial data creation.""" logger.info("Creating initial data") init() logger.info("Initial data created") diff --git a/backend/app/main.py b/backend/app/main.py index 9a95801e74..77e3420255 100644 --- a/backend/app/main.py +++ b/backend/app/main.py @@ -1,4 +1,5 @@ -import sentry_sdk +"""FastAPI application main module.""" + from fastapi import FastAPI from fastapi.routing import APIRoute from starlette.middleware.cors import CORSMiddleware @@ -8,12 +9,10 @@ def custom_generate_unique_id(route: APIRoute) -> str: + """Generate unique ID for API routes.""" return f"{route.tags[0]}-{route.name}" -if settings.SENTRY_DSN and settings.ENVIRONMENT != "local": - sentry_sdk.init(dsn=str(settings.SENTRY_DSN), enable_tracing=True) - app = FastAPI( title=settings.PROJECT_NAME, openapi_url=f"{settings.API_V1_STR}/openapi.json", diff --git a/backend/app/models.py b/backend/app/models.py index 2389b4a532..caa185e2dd 100644 --- a/backend/app/models.py +++ b/backend/app/models.py @@ -1,113 +1,296 @@ +"""Data models for the application.""" + import uuid +from datetime import UTC, datetime +from decimal import Decimal +from enum import Enum from pydantic import EmailStr from sqlmodel import Field, Relationship, SQLModel +from app.constants import ( + EMAIL_MAX_LENGTH, + PASSWORD_MAX_LENGTH, + PASSWORD_MIN_LENGTH, + STRING_MAX_LENGTH, +) + +# Token type constant to avoid hardcoded string +TOKEN_TYPE_BEARER = "bearer" # noqa: S105 + # Shared properties class UserBase(SQLModel): - email: EmailStr = Field(unique=True, index=True, max_length=255) + """Base user model with shared fields.""" + + email: EmailStr = Field(unique=True, index=True, max_length=EMAIL_MAX_LENGTH) is_active: bool = True is_superuser: bool = False - full_name: str | None = Field(default=None, max_length=255) + full_name: str | None = Field(default=None, max_length=STRING_MAX_LENGTH) # Properties to receive via API on creation class UserCreate(UserBase): - password: str = Field(min_length=8, max_length=40) + """User creation model.""" + + password: str = Field( + min_length=PASSWORD_MIN_LENGTH, + max_length=PASSWORD_MAX_LENGTH, + ) class UserRegister(SQLModel): - email: EmailStr = Field(max_length=255) - password: str = Field(min_length=8, max_length=40) - full_name: str | None = Field(default=None, max_length=255) + """User registration model.""" + + email: EmailStr = Field(max_length=EMAIL_MAX_LENGTH) + password: str = Field( + min_length=PASSWORD_MIN_LENGTH, + max_length=PASSWORD_MAX_LENGTH, + ) + full_name: str | None = Field(default=None, max_length=STRING_MAX_LENGTH) # Properties to receive via API on update, all are optional class UserUpdate(UserBase): - email: EmailStr | None = Field(default=None, max_length=255) # type: ignore - password: str | None = Field(default=None, min_length=8, max_length=40) + """User update model.""" + + email: EmailStr | None = Field(default=None, max_length=STRING_MAX_LENGTH) # type: ignore[assignment] + password: str | None = Field( + default=None, + min_length=PASSWORD_MIN_LENGTH, + max_length=PASSWORD_MAX_LENGTH, + ) class UserUpdateMe(SQLModel): - full_name: str | None = Field(default=None, max_length=255) - email: EmailStr | None = Field(default=None, max_length=255) + """User self-update model.""" + + full_name: str | None = Field(default=None, max_length=STRING_MAX_LENGTH) + email: EmailStr | None = Field(default=None, max_length=STRING_MAX_LENGTH) class UpdatePassword(SQLModel): - current_password: str = Field(min_length=8, max_length=40) - new_password: str = Field(min_length=8, max_length=40) + """Password update model.""" + + current_password: str = Field( + min_length=PASSWORD_MIN_LENGTH, + max_length=PASSWORD_MAX_LENGTH, + ) + new_password: str = Field( + min_length=PASSWORD_MIN_LENGTH, + max_length=PASSWORD_MAX_LENGTH, + ) # Database model, database table inferred from class name class User(UserBase, table=True): + """Database user model.""" + id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True) hashed_password: str - items: list["Item"] = Relationship(back_populates="owner", cascade_delete=True) + item_list: list["Item"] = Relationship(back_populates="owner", cascade_delete=True) + wallets: list["Wallet"] = Relationship(back_populates="user", cascade_delete=True) # Properties to return via API, id is always required class UserPublic(UserBase): + """Public user model for API responses.""" + id: uuid.UUID class UsersPublic(SQLModel): - data: list[UserPublic] + """Collection of public users.""" + + user_data: list[UserPublic] count: int # Shared properties class ItemBase(SQLModel): - title: str = Field(min_length=1, max_length=255) - description: str | None = Field(default=None, max_length=255) + """Base item model with shared fields.""" + + title: str = Field(min_length=1, max_length=STRING_MAX_LENGTH) + description: str | None = Field(default=None, max_length=STRING_MAX_LENGTH) # Properties to receive on item creation class ItemCreate(ItemBase): - pass + """Item creation model.""" # Properties to receive on item update class ItemUpdate(ItemBase): - title: str | None = Field(default=None, min_length=1, max_length=255) # type: ignore + """Item update model.""" + + title: str | None = Field(default=None, min_length=1, max_length=STRING_MAX_LENGTH) # type: ignore[assignment] # Database model, database table inferred from class name -class Item(ItemBase, table=True): +class Item(ItemBase, table=True): # noqa: WPS110 + """Database item model.""" + id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True) owner_id: uuid.UUID = Field( - foreign_key="user.id", nullable=False, ondelete="CASCADE" + foreign_key="user.id", + nullable=False, + ondelete="CASCADE", ) - owner: User | None = Relationship(back_populates="items") + owner: User | None = Relationship(back_populates="item_list") # Properties to return via API, id is always required class ItemPublic(ItemBase): + """Public item model for API responses.""" + id: uuid.UUID owner_id: uuid.UUID class ItemsPublic(SQLModel): - data: list[ItemPublic] + """Collection of public items.""" + + item_data: list[ItemPublic] count: int # Generic message class Message(SQLModel): + """Generic message model.""" + message: str # JSON payload containing access token class Token(SQLModel): + """JWT token model.""" + access_token: str - token_type: str = "bearer" + token_type: str = TOKEN_TYPE_BEARER # Contents of JWT token class TokenPayload(SQLModel): + """JWT token payload model.""" + sub: str | None = None class NewPassword(SQLModel): + """New password model.""" + token: str - new_password: str = Field(min_length=8, max_length=40) + new_password: str = Field( + min_length=PASSWORD_MIN_LENGTH, + max_length=PASSWORD_MAX_LENGTH, + ) + + +# Wallet and Transaction enums +class CurrencyType(str, Enum): + """Supported currency types.""" + + USD = "USD" + EUR = "EUR" + RUB = "RUB" + + +class TransactionType(str, Enum): + """Transaction types.""" + + CREDIT = "credit" + DEBIT = "debit" + + +# Wallet models +class WalletBase(SQLModel): + """Base wallet model with shared fields.""" + + balance: Decimal = Field(default=Decimal("0.00"), decimal_places=2, max_digits=12) + currency: CurrencyType + + +class WalletCreate(SQLModel): + """Wallet creation model.""" + + currency: CurrencyType + + +class WalletUpdate(SQLModel): + """Wallet update model.""" + + balance: Decimal | None = Field(default=None, decimal_places=2, max_digits=12) + + +class Wallet(WalletBase, table=True): + """Database wallet model.""" + + id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True) + user_id: uuid.UUID = Field( + foreign_key="user.id", + nullable=False, + ondelete="CASCADE", + ) + user: User | None = Relationship(back_populates="wallets") + transactions: list["Transaction"] = Relationship( + back_populates="wallet", + cascade_delete=True, + ) + + +class WalletPublic(WalletBase): + """Public wallet model for API responses.""" + + id: uuid.UUID + user_id: uuid.UUID + + +class WalletsPublic(SQLModel): + """Collection of public wallets.""" + + wallet_data: list[WalletPublic] + count: int + + +# Transaction models +class TransactionBase(SQLModel): + """Base transaction model with shared fields.""" + + amount: Decimal = Field(decimal_places=2, max_digits=12, gt=0) + transaction_type: TransactionType = Field(alias="type") + timestamp: datetime = Field(default_factory=lambda: datetime.now(UTC)) + currency: CurrencyType + + +class TransactionCreate(SQLModel): + """Transaction creation model.""" + + amount: Decimal = Field(decimal_places=2, max_digits=12, gt=0) + transaction_type: TransactionType = Field(alias="type") + currency: CurrencyType | None = None + + +class Transaction(TransactionBase, table=True): + """Database transaction model.""" + + id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True) + wallet_id: uuid.UUID = Field( + foreign_key="wallet.id", + nullable=False, + ondelete="CASCADE", + ) + wallet: Wallet | None = Relationship(back_populates="transactions") + + +class TransactionPublic(TransactionBase): + """Public transaction model for API responses.""" + + id: uuid.UUID + wallet_id: uuid.UUID + + +class TransactionsPublic(SQLModel): + """Collection of public transactions.""" + + transaction_data: list[TransactionPublic] + count: int diff --git a/backend/app/tests/api/routes/test_items.py b/backend/app/tests/api/routes/test_items.py index c215238a69..74fc1d97e2 100644 --- a/backend/app/tests/api/routes/test_items.py +++ b/backend/app/tests/api/routes/test_items.py @@ -3,162 +3,206 @@ from fastapi.testclient import TestClient from sqlmodel import Session +from app.constants import ( + BAD_REQUEST_CODE, + NOT_FOUND_CODE, + OK_CODE, +) from app.core.config import settings +from app.models import Item from app.tests.utils.item import create_random_item +# Constants for commonly used strings +TEST_ITEM_TITLE = "title" +TEST_ITEM_DESCRIPTION = "description" +ITEMS_ENDPOINT = "/items/" +ERROR_DETAIL_KEY = "detail" + + +def _create_test_item(db: Session) -> Item: + """Create a test item and reduce expression reuse.""" + return create_random_item(db) + def test_create_item( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: - data = {"title": "Foo", "description": "Fighters"} + item_data = {TEST_ITEM_TITLE: "Foo", TEST_ITEM_DESCRIPTION: "Fighters"} response = client.post( - f"{settings.API_V1_STR}/items/", + f"{settings.API_V1_STR}{ITEMS_ENDPOINT}", headers=superuser_token_headers, - json=data, + json=item_data, ) - assert response.status_code == 200 - content = response.json() - assert content["title"] == data["title"] - assert content["description"] == data["description"] - assert "id" in content - assert "owner_id" in content + assert response.status_code == OK_CODE + response_content = response.json() + assert response_content[TEST_ITEM_TITLE] == item_data[TEST_ITEM_TITLE] + assert response_content[TEST_ITEM_DESCRIPTION] == item_data[TEST_ITEM_DESCRIPTION] + assert "id" in response_content + assert "owner_id" in response_content def test_read_item( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: - item = create_random_item(db) + test_item = _create_test_item(db) response = client.get( - f"{settings.API_V1_STR}/items/{item.id}", + f"{settings.API_V1_STR}{ITEMS_ENDPOINT}{test_item.id}", headers=superuser_token_headers, ) - assert response.status_code == 200 - content = response.json() - assert content["title"] == item.title - assert content["description"] == item.description - assert content["id"] == str(item.id) - assert content["owner_id"] == str(item.owner_id) + assert response.status_code == OK_CODE + response_content = response.json() + assert response_content[TEST_ITEM_TITLE] == test_item.title + assert response_content[TEST_ITEM_DESCRIPTION] == test_item.description + assert response_content["id"] == str(test_item.id) + assert response_content["owner_id"] == str(test_item.owner_id) def test_read_item_not_found( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: response = client.get( - f"{settings.API_V1_STR}/items/{uuid.uuid4()}", + f"{settings.API_V1_STR}{ITEMS_ENDPOINT}{uuid.uuid4()}", headers=superuser_token_headers, ) - assert response.status_code == 404 - content = response.json() - assert content["detail"] == "Item not found" + assert response.status_code == NOT_FOUND_CODE + response_content = response.json() + assert response_content[ERROR_DETAIL_KEY] == "Item not found" def test_read_item_not_enough_permissions( - client: TestClient, normal_user_token_headers: dict[str, str], db: Session + client: TestClient, + normal_user_token_headers: dict[str, str], + db: Session, ) -> None: - item = create_random_item(db) + test_item = _create_test_item(db) response = client.get( - f"{settings.API_V1_STR}/items/{item.id}", + f"{settings.API_V1_STR}{ITEMS_ENDPOINT}{test_item.id}", headers=normal_user_token_headers, ) - assert response.status_code == 400 - content = response.json() - assert content["detail"] == "Not enough permissions" + assert response.status_code == BAD_REQUEST_CODE + response_content = response.json() + assert response_content[ERROR_DETAIL_KEY] == "Not enough permissions" def test_read_items( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: - create_random_item(db) - create_random_item(db) + _create_test_item(db) + _create_test_item(db) response = client.get( - f"{settings.API_V1_STR}/items/", + f"{settings.API_V1_STR}{ITEMS_ENDPOINT}", headers=superuser_token_headers, ) - assert response.status_code == 200 - content = response.json() - assert len(content["data"]) >= 2 + assert response.status_code == OK_CODE + response_content = response.json() + assert len(response_content["data"]) >= 2 def test_update_item( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: - item = create_random_item(db) - data = {"title": "Updated title", "description": "Updated description"} + test_item = _create_test_item(db) + update_data = { + TEST_ITEM_TITLE: "Updated title", + TEST_ITEM_DESCRIPTION: "Updated description", + } response = client.put( - f"{settings.API_V1_STR}/items/{item.id}", + f"{settings.API_V1_STR}{ITEMS_ENDPOINT}{test_item.id}", headers=superuser_token_headers, - json=data, + json=update_data, ) - assert response.status_code == 200 - content = response.json() - assert content["title"] == data["title"] - assert content["description"] == data["description"] - assert content["id"] == str(item.id) - assert content["owner_id"] == str(item.owner_id) + assert response.status_code == OK_CODE + response_content = response.json() + assert response_content[TEST_ITEM_TITLE] == update_data[TEST_ITEM_TITLE] + assert response_content[TEST_ITEM_DESCRIPTION] == update_data[TEST_ITEM_DESCRIPTION] + assert response_content["id"] == str(test_item.id) + assert response_content["owner_id"] == str(test_item.owner_id) def test_update_item_not_found( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: - data = {"title": "Updated title", "description": "Updated description"} + update_data = { + TEST_ITEM_TITLE: "Updated title", + TEST_ITEM_DESCRIPTION: "Updated description", + } response = client.put( - f"{settings.API_V1_STR}/items/{uuid.uuid4()}", + f"{settings.API_V1_STR}{ITEMS_ENDPOINT}{uuid.uuid4()}", headers=superuser_token_headers, - json=data, + json=update_data, ) - assert response.status_code == 404 - content = response.json() - assert content["detail"] == "Item not found" + assert response.status_code == NOT_FOUND_CODE + response_content = response.json() + assert response_content[ERROR_DETAIL_KEY] == "Item not found" def test_update_item_not_enough_permissions( - client: TestClient, normal_user_token_headers: dict[str, str], db: Session + client: TestClient, + normal_user_token_headers: dict[str, str], + db: Session, ) -> None: - item = create_random_item(db) - data = {"title": "Updated title", "description": "Updated description"} + test_item = _create_test_item(db) + update_data = { + TEST_ITEM_TITLE: "Updated title", + TEST_ITEM_DESCRIPTION: "Updated description", + } response = client.put( - f"{settings.API_V1_STR}/items/{item.id}", + f"{settings.API_V1_STR}{ITEMS_ENDPOINT}{test_item.id}", headers=normal_user_token_headers, - json=data, + json=update_data, ) - assert response.status_code == 400 - content = response.json() - assert content["detail"] == "Not enough permissions" + assert response.status_code == BAD_REQUEST_CODE + response_content = response.json() + assert response_content[ERROR_DETAIL_KEY] == "Not enough permissions" def test_delete_item( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: - item = create_random_item(db) + test_item = _create_test_item(db) response = client.delete( - f"{settings.API_V1_STR}/items/{item.id}", + f"{settings.API_V1_STR}{ITEMS_ENDPOINT}{test_item.id}", headers=superuser_token_headers, ) - assert response.status_code == 200 - content = response.json() - assert content["message"] == "Item deleted successfully" + assert response.status_code == OK_CODE + response_content = response.json() + assert response_content["message"] == "Item deleted successfully" def test_delete_item_not_found( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: response = client.delete( - f"{settings.API_V1_STR}/items/{uuid.uuid4()}", + f"{settings.API_V1_STR}{ITEMS_ENDPOINT}{uuid.uuid4()}", headers=superuser_token_headers, ) - assert response.status_code == 404 - content = response.json() - assert content["detail"] == "Item not found" + assert response.status_code == NOT_FOUND_CODE + response_content = response.json() + assert response_content[ERROR_DETAIL_KEY] == "Item not found" def test_delete_item_not_enough_permissions( - client: TestClient, normal_user_token_headers: dict[str, str], db: Session + client: TestClient, + normal_user_token_headers: dict[str, str], + db: Session, ) -> None: - item = create_random_item(db) + test_item = _create_test_item(db) response = client.delete( - f"{settings.API_V1_STR}/items/{item.id}", + f"{settings.API_V1_STR}{ITEMS_ENDPOINT}{test_item.id}", headers=normal_user_token_headers, ) - assert response.status_code == 400 - content = response.json() - assert content["detail"] == "Not enough permissions" + assert response.status_code == BAD_REQUEST_CODE + response_content = response.json() + assert response_content[ERROR_DETAIL_KEY] == "Not enough permissions" diff --git a/backend/app/tests/api/routes/test_login.py b/backend/app/tests/api/routes/test_login.py index 80fa787979..14563d8351 100644 --- a/backend/app/tests/api/routes/test_login.py +++ b/backend/app/tests/api/routes/test_login.py @@ -3,13 +3,33 @@ from fastapi.testclient import TestClient from sqlmodel import Session +from app.constants import ( + BAD_REQUEST_CODE, + NOT_FOUND_CODE, + OK_CODE, +) from app.core.config import settings from app.core.security import verify_password from app.crud import create_user -from app.models import UserCreate +from app.email_utils import generate_password_reset_token +from app.models import User, UserCreate +from app.tests.utils.test_helpers import random_email, random_lower_string from app.tests.utils.user import user_authentication_headers -from app.tests.utils.utils import random_email, random_lower_string -from app.utils import generate_password_reset_token + + +def _create_test_user_with_credentials(db: Session) -> tuple[User, str, str]: + """Create a test user and return user data and credentials.""" + email = random_email() + password = random_lower_string() + user_create = UserCreate( + email=email, + full_name="Test User", + password=password, + is_active=True, + is_superuser=False, + ) + user = create_user(session=db, user_create=user_create) + return user, email, password def test_get_access_token(client: TestClient) -> None: @@ -17,11 +37,11 @@ def test_get_access_token(client: TestClient) -> None: "username": settings.FIRST_SUPERUSER, "password": settings.FIRST_SUPERUSER_PASSWORD, } - r = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data) - tokens = r.json() - assert r.status_code == 200 - assert "access_token" in tokens - assert tokens["access_token"] + response = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data) + response_data = response.json() + assert response.status_code == OK_CODE + assert "access_token" in response_data + assert response_data["access_token"] def test_get_access_token_incorrect_password(client: TestClient) -> None: @@ -29,90 +49,85 @@ def test_get_access_token_incorrect_password(client: TestClient) -> None: "username": settings.FIRST_SUPERUSER, "password": "incorrect", } - r = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data) - assert r.status_code == 400 + response = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data) + assert response.status_code == BAD_REQUEST_CODE def test_use_access_token( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: - r = client.post( + response = client.post( f"{settings.API_V1_STR}/login/test-token", headers=superuser_token_headers, ) - result = r.json() - assert r.status_code == 200 - assert "email" in result + response_data = response.json() + assert response.status_code == OK_CODE + assert "email" in response_data def test_recovery_password( - client: TestClient, normal_user_token_headers: dict[str, str] + client: TestClient, + normal_user_token_headers: dict[str, str], ) -> None: with ( patch("app.core.config.settings.SMTP_HOST", "smtp.example.com"), patch("app.core.config.settings.SMTP_USER", "admin@example.com"), ): email = "test@example.com" - r = client.post( + response = client.post( f"{settings.API_V1_STR}/password-recovery/{email}", headers=normal_user_token_headers, ) - assert r.status_code == 200 - assert r.json() == {"message": "Password recovery email sent"} + assert response.status_code == OK_CODE + assert response.json() == {"message": "Password recovery email sent"} def test_recovery_password_user_not_exits( - client: TestClient, normal_user_token_headers: dict[str, str] + client: TestClient, + normal_user_token_headers: dict[str, str], ) -> None: email = "jVgQr@example.com" - r = client.post( + response = client.post( f"{settings.API_V1_STR}/password-recovery/{email}", headers=normal_user_token_headers, ) - assert r.status_code == 404 + assert response.status_code == NOT_FOUND_CODE def test_reset_password(client: TestClient, db: Session) -> None: - email = random_email() - password = random_lower_string() + user, email, password = _create_test_user_with_credentials(db) new_password = random_lower_string() - user_create = UserCreate( - email=email, - full_name="Test User", - password=password, - is_active=True, - is_superuser=False, - ) - user = create_user(session=db, user_create=user_create) token = generate_password_reset_token(email=email) headers = user_authentication_headers(client=client, email=email, password=password) - data = {"new_password": new_password, "token": token} + reset_data = {"new_password": new_password, "token": token} - r = client.post( + response = client.post( f"{settings.API_V1_STR}/reset-password/", headers=headers, - json=data, + json=reset_data, ) - assert r.status_code == 200 - assert r.json() == {"message": "Password updated successfully"} + assert response.status_code == OK_CODE + assert response.json() == {"message": "Password updated successfully"} db.refresh(user) assert verify_password(new_password, user.hashed_password) def test_reset_password_invalid_token( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: - data = {"new_password": "changethis", "token": "invalid"} - r = client.post( + reset_data = {"new_password": "changethis", "token": "invalid"} + response = client.post( f"{settings.API_V1_STR}/reset-password/", headers=superuser_token_headers, - json=data, + json=reset_data, ) - response = r.json() + response_content = response.json() - assert "detail" in response - assert r.status_code == 400 - assert response["detail"] == "Invalid token" + assert "detail" in response_content + assert response.status_code == BAD_REQUEST_CODE + assert response_content["detail"] == "Invalid token" diff --git a/backend/app/tests/api/routes/test_private.py b/backend/app/tests/api/routes/test_private.py index 1e1f985021..2f6af9278a 100644 --- a/backend/app/tests/api/routes/test_private.py +++ b/backend/app/tests/api/routes/test_private.py @@ -1,26 +1,28 @@ from fastapi.testclient import TestClient from sqlmodel import Session, select +from app.constants import OK_CODE from app.core.config import settings from app.models import User def test_create_user(client: TestClient, db: Session) -> None: - r = client.post( - f"{settings.API_V1_STR}/private/users/", - json={ - "email": "pollo@listo.com", - "password": "password123", - "full_name": "Pollo Listo", - }, - ) + # Create user data + user_data = { + "email": "pollo@listo.com", + "password": "password123", + "full_name": "Pollo Listo", + } - assert r.status_code == 200 + # Make request + response = client.post(f"{settings.API_V1_STR}/private/users/", json=user_data) + assert response.status_code == OK_CODE - data = r.json() + # Get response data + response_data = response.json() - user = db.exec(select(User).where(User.id == data["id"])).first() - - assert user - assert user.email == "pollo@listo.com" - assert user.full_name == "Pollo Listo" + # Verify user was created in database + created_user = db.exec(select(User).where(User.id == response_data["id"])).first() + assert created_user + assert created_user.email == user_data["email"] + assert created_user.full_name == user_data["full_name"] diff --git a/backend/app/tests/api/routes/test_users.py b/backend/app/tests/api/routes/test_users.py index ba9be65426..cd8e43e5d7 100644 --- a/backend/app/tests/api/routes/test_users.py +++ b/backend/app/tests/api/routes/test_users.py @@ -5,184 +5,247 @@ from sqlmodel import Session, select from app import crud +from app.constants import ( + BAD_REQUEST_CODE, + CONFLICT_CODE, + FORBIDDEN_CODE, + NOT_FOUND_CODE, + OK_CODE, +) from app.core.config import settings from app.core.security import verify_password from app.models import User, UserCreate -from app.tests.utils.utils import random_email, random_lower_string +from app.tests.utils.test_helpers import random_email, random_lower_string + + +# Helper functions to reduce complexity +def create_test_user_data() -> dict[str, str]: + """Create random user data for testing.""" + return { + "username": random_email(), + "password": random_lower_string(), + } + + +def create_user_in_db( + db: Session, + username: str | None = None, + password: str | None = None, +) -> User: + """Create a user in the database and return it.""" + if username is None: + username = random_email() + if password is None: + password = random_lower_string() + user_in = UserCreate(email=username, password=password) + return crud.create_user(session=db, user_create=user_in) + + +def authenticate_user( + client: TestClient, + username: str, + password: str, +) -> dict[str, str]: + """Authenticate a user and return headers.""" + login_data = {"username": username, USER_PASSWORD_KEY: password} + response = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data) + response_data = response.json() + access_token = response_data["access_token"] + return {"Authorization": f"Bearer {access_token}"} + + +# Constants for commonly used strings +USER_EMAIL_KEY = "email" +USER_PASSWORD_KEY = "password" # noqa: S105 +USER_FULL_NAME_KEY = "full_name" +USER_CURRENT_PASSWORD_KEY = "current_password" # noqa: S105 +USER_NEW_PASSWORD_KEY = "new_password" # noqa: S105 +USERS_ME_ENDPOINT = "/users/me" +USERS_ENDPOINT = "/users/" +USERS_ME_PASSWORD_ENDPOINT = "/users/me/password" # noqa: S105 +USERS_SIGNUP_ENDPOINT = "/users/signup" +USERS_BASE_ENDPOINT = "/users/" # For constructing /users/{id} endpoints +ERROR_DETAIL_KEY = "detail" +UPDATED_FULL_NAME = "Updated_full_name" def test_get_users_superuser_me( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: - r = client.get(f"{settings.API_V1_STR}/users/me", headers=superuser_token_headers) - current_user = r.json() + response = client.get( + f"{settings.API_V1_STR}{USERS_ME_ENDPOINT}", + headers=superuser_token_headers, + ) + current_user = response.json() assert current_user assert current_user["is_active"] is True assert current_user["is_superuser"] - assert current_user["email"] == settings.FIRST_SUPERUSER + assert current_user[USER_EMAIL_KEY] == settings.FIRST_SUPERUSER def test_get_users_normal_user_me( - client: TestClient, normal_user_token_headers: dict[str, str] + client: TestClient, + normal_user_token_headers: dict[str, str], ) -> None: - r = client.get(f"{settings.API_V1_STR}/users/me", headers=normal_user_token_headers) - current_user = r.json() + response = client.get( + f"{settings.API_V1_STR}{USERS_ME_ENDPOINT}", + headers=normal_user_token_headers, + ) + current_user = response.json() assert current_user assert current_user["is_active"] is True assert current_user["is_superuser"] is False - assert current_user["email"] == settings.EMAIL_TEST_USER + assert current_user[USER_EMAIL_KEY] == settings.EMAIL_TEST_USER def test_create_user_new_email( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: with ( patch("app.utils.send_email", return_value=None), patch("app.core.config.settings.SMTP_HOST", "smtp.example.com"), patch("app.core.config.settings.SMTP_USER", "admin@example.com"), ): - username = random_email() - password = random_lower_string() - data = {"email": username, "password": password} - r = client.post( - f"{settings.API_V1_STR}/users/", + test_data = create_test_user_data() + user_data = { + USER_EMAIL_KEY: test_data["username"], + USER_PASSWORD_KEY: test_data["password"], + } + response = client.post( + f"{settings.API_V1_STR}{USERS_ENDPOINT}", headers=superuser_token_headers, - json=data, + json=user_data, ) - assert 200 <= r.status_code < 300 - created_user = r.json() - user = crud.get_user_by_email(session=db, email=username) + assert response.status_code == OK_CODE + created_user = response.json() + user = crud.get_user_by_email(session=db, email=test_data["username"]) assert user - assert user.email == created_user["email"] + assert user.email == created_user[USER_EMAIL_KEY] def test_get_existing_user( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: - username = random_email() - password = random_lower_string() - user_in = UserCreate(email=username, password=password) - user = crud.create_user(session=db, user_create=user_in) - user_id = user.id - r = client.get( - f"{settings.API_V1_STR}/users/{user_id}", + user = create_user_in_db(db) + response = client.get( + f"{settings.API_V1_STR}{USERS_BASE_ENDPOINT}{user.id}", headers=superuser_token_headers, ) - assert 200 <= r.status_code < 300 - api_user = r.json() - existing_user = crud.get_user_by_email(session=db, email=username) + assert response.status_code == OK_CODE + api_user = response.json() + existing_user = crud.get_user_by_email(session=db, email=user.email) assert existing_user - assert existing_user.email == api_user["email"] + assert existing_user.email == api_user[USER_EMAIL_KEY] def test_get_existing_user_current_user(client: TestClient, db: Session) -> None: - username = random_email() - password = random_lower_string() - user_in = UserCreate(email=username, password=password) - user = crud.create_user(session=db, user_create=user_in) - user_id = user.id + test_data = create_test_user_data() + user = create_user_in_db(db, test_data["username"], test_data["password"]) + headers = authenticate_user(client, test_data["username"], test_data["password"]) - login_data = { - "username": username, - "password": password, - } - r = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data) - tokens = r.json() - a_token = tokens["access_token"] - headers = {"Authorization": f"Bearer {a_token}"} - - r = client.get( - f"{settings.API_V1_STR}/users/{user_id}", + response = client.get( + f"{settings.API_V1_STR}{USERS_BASE_ENDPOINT}{user.id}", headers=headers, ) - assert 200 <= r.status_code < 300 - api_user = r.json() - existing_user = crud.get_user_by_email(session=db, email=username) + assert response.status_code == OK_CODE + api_user = response.json() + existing_user = crud.get_user_by_email(session=db, email=test_data["username"]) assert existing_user - assert existing_user.email == api_user["email"] + assert existing_user.email == api_user[USER_EMAIL_KEY] def test_get_existing_user_permissions_error( - client: TestClient, normal_user_token_headers: dict[str, str] + client: TestClient, + normal_user_token_headers: dict[str, str], ) -> None: - r = client.get( - f"{settings.API_V1_STR}/users/{uuid.uuid4()}", + response = client.get( + f"{settings.API_V1_STR}{USERS_BASE_ENDPOINT}{uuid.uuid4()}", headers=normal_user_token_headers, ) - assert r.status_code == 403 - assert r.json() == {"detail": "The user doesn't have enough privileges"} + assert response.status_code == FORBIDDEN_CODE + assert response.json() == { + ERROR_DETAIL_KEY: "The user doesn't have enough privileges", + } def test_create_user_existing_username( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: - username = random_email() - # username = email - password = random_lower_string() - user_in = UserCreate(email=username, password=password) - crud.create_user(session=db, user_create=user_in) - data = {"email": username, "password": password} - r = client.post( - f"{settings.API_V1_STR}/users/", + test_data = create_test_user_data() + create_user_in_db(db, test_data["username"], test_data["password"]) + user_data = { + USER_EMAIL_KEY: test_data["username"], + USER_PASSWORD_KEY: test_data["password"], + } + response = client.post( + f"{settings.API_V1_STR}{USERS_ENDPOINT}", headers=superuser_token_headers, - json=data, + json=user_data, ) - created_user = r.json() - assert r.status_code == 400 + created_user = response.json() + assert response.status_code == BAD_REQUEST_CODE assert "_id" not in created_user def test_create_user_by_normal_user( - client: TestClient, normal_user_token_headers: dict[str, str] + client: TestClient, + normal_user_token_headers: dict[str, str], ) -> None: username = random_email() password = random_lower_string() - data = {"email": username, "password": password} - r = client.post( - f"{settings.API_V1_STR}/users/", + user_data = {USER_EMAIL_KEY: username, USER_PASSWORD_KEY: password} + response = client.post( + f"{settings.API_V1_STR}{USERS_ENDPOINT}", headers=normal_user_token_headers, - json=data, + json=user_data, ) - assert r.status_code == 403 + assert response.status_code == FORBIDDEN_CODE def test_retrieve_users( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: - username = random_email() - password = random_lower_string() - user_in = UserCreate(email=username, password=password) - crud.create_user(session=db, user_create=user_in) + create_user_in_db(db) + create_user_in_db(db) - username2 = random_email() - password2 = random_lower_string() - user_in2 = UserCreate(email=username2, password=password2) - crud.create_user(session=db, user_create=user_in2) - - r = client.get(f"{settings.API_V1_STR}/users/", headers=superuser_token_headers) - all_users = r.json() + response = client.get( + f"{settings.API_V1_STR}{USERS_ENDPOINT}", + headers=superuser_token_headers, + ) + all_users = response.json() assert len(all_users["data"]) > 1 assert "count" in all_users - for item in all_users["data"]: - assert "email" in item + for user_data in all_users["data"]: + assert USER_EMAIL_KEY in user_data def test_update_user_me( - client: TestClient, normal_user_token_headers: dict[str, str], db: Session + client: TestClient, + normal_user_token_headers: dict[str, str], + db: Session, ) -> None: full_name = "Updated Name" email = random_email() - data = {"full_name": full_name, "email": email} - r = client.patch( - f"{settings.API_V1_STR}/users/me", + update_data = {USER_FULL_NAME_KEY: full_name, USER_EMAIL_KEY: email} + response = client.patch( + f"{settings.API_V1_STR}{USERS_ME_ENDPOINT}", headers=normal_user_token_headers, - json=data, + json=update_data, ) - assert r.status_code == 200 - updated_user = r.json() - assert updated_user["email"] == email - assert updated_user["full_name"] == full_name + assert response.status_code == OK_CODE + updated_user = response.json() + assert updated_user[USER_EMAIL_KEY] == email + assert updated_user[USER_FULL_NAME_KEY] == full_name user_query = select(User).where(User.email == email) user_db = db.exec(user_query).first() @@ -192,295 +255,304 @@ def test_update_user_me( def test_update_password_me( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: new_password = random_lower_string() - data = { - "current_password": settings.FIRST_SUPERUSER_PASSWORD, - "new_password": new_password, + password_data = { + USER_CURRENT_PASSWORD_KEY: settings.FIRST_SUPERUSER_PASSWORD, + USER_NEW_PASSWORD_KEY: new_password, } - r = client.patch( - f"{settings.API_V1_STR}/users/me/password", + response = client.patch( + f"{settings.API_V1_STR}{USERS_ME_PASSWORD_ENDPOINT}", headers=superuser_token_headers, - json=data, + json=password_data, ) - assert r.status_code == 200 - updated_user = r.json() + assert response.status_code == OK_CODE + updated_user = response.json() assert updated_user["message"] == "Password updated successfully" user_query = select(User).where(User.email == settings.FIRST_SUPERUSER) user_db = db.exec(user_query).first() assert user_db - assert user_db.email == settings.FIRST_SUPERUSER assert verify_password(new_password, user_db.hashed_password) # Revert to the old password to keep consistency in test - old_data = { - "current_password": new_password, - "new_password": settings.FIRST_SUPERUSER_PASSWORD, + _revert_superuser_password(client, superuser_token_headers, new_password) + + +def _revert_superuser_password( + client: TestClient, + superuser_token_headers: dict[str, str], + new_password: str, +) -> None: + """Revert superuser password for test consistency.""" + revert_data = { + USER_CURRENT_PASSWORD_KEY: new_password, + USER_NEW_PASSWORD_KEY: settings.FIRST_SUPERUSER_PASSWORD, } - r = client.patch( - f"{settings.API_V1_STR}/users/me/password", + response = client.patch( + f"{settings.API_V1_STR}{USERS_ME_PASSWORD_ENDPOINT}", headers=superuser_token_headers, - json=old_data, + json=revert_data, ) - db.refresh(user_db) - - assert r.status_code == 200 - assert verify_password(settings.FIRST_SUPERUSER_PASSWORD, user_db.hashed_password) + assert response.status_code == OK_CODE def test_update_password_me_incorrect_password( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: new_password = random_lower_string() - data = {"current_password": new_password, "new_password": new_password} - r = client.patch( - f"{settings.API_V1_STR}/users/me/password", + password_data = {"current_password": new_password, "new_password": new_password} + response = client.patch( + f"{settings.API_V1_STR}{USERS_ME_PASSWORD_ENDPOINT}", headers=superuser_token_headers, - json=data, + json=password_data, ) - assert r.status_code == 400 - updated_user = r.json() - assert updated_user["detail"] == "Incorrect password" + assert response.status_code == BAD_REQUEST_CODE + updated_user = response.json() + assert updated_user[ERROR_DETAIL_KEY] == "Incorrect password" def test_update_user_me_email_exists( - client: TestClient, normal_user_token_headers: dict[str, str], db: Session + client: TestClient, + normal_user_token_headers: dict[str, str], + db: Session, ) -> None: - username = random_email() - password = random_lower_string() - user_in = UserCreate(email=username, password=password) - user = crud.create_user(session=db, user_create=user_in) + user = create_user_in_db(db) - data = {"email": user.email} - r = client.patch( - f"{settings.API_V1_STR}/users/me", + update_data = {USER_EMAIL_KEY: user.email} + response = client.patch( + f"{settings.API_V1_STR}{USERS_ME_ENDPOINT}", headers=normal_user_token_headers, - json=data, + json=update_data, ) - assert r.status_code == 409 - assert r.json()["detail"] == "User with this email already exists" + assert response.status_code == CONFLICT_CODE + assert response.json()[ERROR_DETAIL_KEY] == "User with this email already exists" def test_update_password_me_same_password_error( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: - data = { - "current_password": settings.FIRST_SUPERUSER_PASSWORD, - "new_password": settings.FIRST_SUPERUSER_PASSWORD, + password_data = { + USER_CURRENT_PASSWORD_KEY: settings.FIRST_SUPERUSER_PASSWORD, + USER_NEW_PASSWORD_KEY: settings.FIRST_SUPERUSER_PASSWORD, } - r = client.patch( - f"{settings.API_V1_STR}/users/me/password", + response = client.patch( + f"{settings.API_V1_STR}{USERS_ME_PASSWORD_ENDPOINT}", headers=superuser_token_headers, - json=data, + json=password_data, ) - assert r.status_code == 400 - updated_user = r.json() + assert response.status_code == BAD_REQUEST_CODE + updated_user = response.json() assert ( - updated_user["detail"] == "New password cannot be the same as the current one" + updated_user[ERROR_DETAIL_KEY] + == "New password cannot be the same as the current one" ) def test_register_user(client: TestClient, db: Session) -> None: - username = random_email() - password = random_lower_string() + test_data = create_test_user_data() full_name = random_lower_string() - data = {"email": username, "password": password, "full_name": full_name} - r = client.post( - f"{settings.API_V1_STR}/users/signup", - json=data, + signup_data = { + USER_EMAIL_KEY: test_data["username"], + USER_PASSWORD_KEY: test_data["password"], + USER_FULL_NAME_KEY: full_name, + } + response = client.post( + f"{settings.API_V1_STR}{USERS_SIGNUP_ENDPOINT}", + json=signup_data, ) - assert r.status_code == 200 - created_user = r.json() - assert created_user["email"] == username - assert created_user["full_name"] == full_name + assert response.status_code == OK_CODE + created_user = response.json() + assert created_user[USER_EMAIL_KEY] == test_data["username"] + assert created_user[USER_FULL_NAME_KEY] == full_name - user_query = select(User).where(User.email == username) + user_query = select(User).where(User.email == test_data["username"]) user_db = db.exec(user_query).first() assert user_db - assert user_db.email == username + assert user_db.email == test_data["username"] assert user_db.full_name == full_name - assert verify_password(password, user_db.hashed_password) + assert verify_password(test_data["password"], user_db.hashed_password) def test_register_user_already_exists_error(client: TestClient) -> None: password = random_lower_string() full_name = random_lower_string() - data = { - "email": settings.FIRST_SUPERUSER, - "password": password, - "full_name": full_name, + signup_data = { + USER_EMAIL_KEY: settings.FIRST_SUPERUSER, + USER_PASSWORD_KEY: password, + USER_FULL_NAME_KEY: full_name, } - r = client.post( - f"{settings.API_V1_STR}/users/signup", - json=data, + response = client.post( + f"{settings.API_V1_STR}{USERS_SIGNUP_ENDPOINT}", + json=signup_data, + ) + assert response.status_code == BAD_REQUEST_CODE + assert ( + response.json()[ERROR_DETAIL_KEY] + == "The user with this email already exists in the system" ) - assert r.status_code == 400 - assert r.json()["detail"] == "The user with this email already exists in the system" def test_update_user( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: - username = random_email() - password = random_lower_string() - user_in = UserCreate(email=username, password=password) - user = crud.create_user(session=db, user_create=user_in) + user = create_user_in_db(db) - data = {"full_name": "Updated_full_name"} - r = client.patch( - f"{settings.API_V1_STR}/users/{user.id}", + update_data = {USER_FULL_NAME_KEY: UPDATED_FULL_NAME} + response = client.patch( + f"{settings.API_V1_STR}{USERS_BASE_ENDPOINT}{user.id}", headers=superuser_token_headers, - json=data, + json=update_data, ) - assert r.status_code == 200 - updated_user = r.json() + assert response.status_code == OK_CODE + updated_user = response.json() - assert updated_user["full_name"] == "Updated_full_name" + assert updated_user[USER_FULL_NAME_KEY] == UPDATED_FULL_NAME - user_query = select(User).where(User.email == username) + user_query = select(User).where(User.email == user.email) user_db = db.exec(user_query).first() db.refresh(user_db) assert user_db - assert user_db.full_name == "Updated_full_name" + assert user_db.full_name == UPDATED_FULL_NAME def test_update_user_not_exists( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: - data = {"full_name": "Updated_full_name"} - r = client.patch( - f"{settings.API_V1_STR}/users/{uuid.uuid4()}", + update_data = {USER_FULL_NAME_KEY: UPDATED_FULL_NAME} + response = client.patch( + f"{settings.API_V1_STR}{USERS_BASE_ENDPOINT}{uuid.uuid4()}", headers=superuser_token_headers, - json=data, + json=update_data, + ) + assert response.status_code == NOT_FOUND_CODE + assert ( + response.json()[ERROR_DETAIL_KEY] + == "The user with this id does not exist in the system" ) - assert r.status_code == 404 - assert r.json()["detail"] == "The user with this id does not exist in the system" def test_update_user_email_exists( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: - username = random_email() - password = random_lower_string() - user_in = UserCreate(email=username, password=password) - user = crud.create_user(session=db, user_create=user_in) + user = create_user_in_db(db) + second_user = create_user_in_db(db) - username2 = random_email() - password2 = random_lower_string() - user_in2 = UserCreate(email=username2, password=password2) - user2 = crud.create_user(session=db, user_create=user_in2) - - data = {"email": user2.email} - r = client.patch( - f"{settings.API_V1_STR}/users/{user.id}", + update_data = {USER_EMAIL_KEY: second_user.email} + response = client.patch( + f"{settings.API_V1_STR}{USERS_BASE_ENDPOINT}{user.id}", headers=superuser_token_headers, - json=data, + json=update_data, ) - assert r.status_code == 409 - assert r.json()["detail"] == "User with this email already exists" + assert response.status_code == CONFLICT_CODE + assert response.json()[ERROR_DETAIL_KEY] == "User with this email already exists" def test_delete_user_me(client: TestClient, db: Session) -> None: - username = random_email() - password = random_lower_string() - user_in = UserCreate(email=username, password=password) - user = crud.create_user(session=db, user_create=user_in) - user_id = user.id + test_data = create_test_user_data() + user = create_user_in_db(db, test_data["username"], test_data["password"]) + headers = authenticate_user(client, test_data["username"], test_data["password"]) - login_data = { - "username": username, - "password": password, - } - r = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data) - tokens = r.json() - a_token = tokens["access_token"] - headers = {"Authorization": f"Bearer {a_token}"} - - r = client.delete( - f"{settings.API_V1_STR}/users/me", + response = client.delete( + f"{settings.API_V1_STR}{USERS_ME_ENDPOINT}", headers=headers, ) - assert r.status_code == 200 - deleted_user = r.json() + assert response.status_code == OK_CODE + deleted_user = response.json() assert deleted_user["message"] == "User deleted successfully" - result = db.exec(select(User).where(User.id == user_id)).first() - assert result is None - user_query = select(User).where(User.id == user_id) - user_db = db.execute(user_query).first() - assert user_db is None + # Verify user is deleted + deleted_user_check = db.exec(select(User).where(User.id == user.id)).first() + assert deleted_user_check is None def test_delete_user_me_as_superuser( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: - r = client.delete( - f"{settings.API_V1_STR}/users/me", + response = client.delete( + f"{settings.API_V1_STR}{USERS_ME_ENDPOINT}", headers=superuser_token_headers, ) - assert r.status_code == 403 - response = r.json() - assert response["detail"] == "Super users are not allowed to delete themselves" + assert response.status_code == FORBIDDEN_CODE + response_content = response.json() + assert ( + response_content[ERROR_DETAIL_KEY] + == "Super users are not allowed to delete themselves" + ) def test_delete_user_super_user( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: - username = random_email() - password = random_lower_string() - user_in = UserCreate(email=username, password=password) - user = crud.create_user(session=db, user_create=user_in) - user_id = user.id - r = client.delete( - f"{settings.API_V1_STR}/users/{user_id}", + user = create_user_in_db(db) + response = client.delete( + f"{settings.API_V1_STR}{USERS_BASE_ENDPOINT}{user.id}", headers=superuser_token_headers, ) - assert r.status_code == 200 - deleted_user = r.json() + assert response.status_code == OK_CODE + deleted_user = response.json() assert deleted_user["message"] == "User deleted successfully" - result = db.exec(select(User).where(User.id == user_id)).first() - assert result is None + deleted_user_check = db.exec(select(User).where(User.id == user.id)).first() + assert deleted_user_check is None def test_delete_user_not_found( - client: TestClient, superuser_token_headers: dict[str, str] + client: TestClient, + superuser_token_headers: dict[str, str], ) -> None: - r = client.delete( - f"{settings.API_V1_STR}/users/{uuid.uuid4()}", + response = client.delete( + f"{settings.API_V1_STR}{USERS_BASE_ENDPOINT}{uuid.uuid4()}", headers=superuser_token_headers, ) - assert r.status_code == 404 - assert r.json()["detail"] == "User not found" + assert response.status_code == NOT_FOUND_CODE + assert response.json()[ERROR_DETAIL_KEY] == "User not found" def test_delete_user_current_super_user_error( - client: TestClient, superuser_token_headers: dict[str, str], db: Session + client: TestClient, + superuser_token_headers: dict[str, str], + db: Session, ) -> None: super_user = crud.get_user_by_email(session=db, email=settings.FIRST_SUPERUSER) assert super_user user_id = super_user.id - r = client.delete( - f"{settings.API_V1_STR}/users/{user_id}", + response = client.delete( + f"{settings.API_V1_STR}{USERS_BASE_ENDPOINT}{user_id}", headers=superuser_token_headers, ) - assert r.status_code == 403 - assert r.json()["detail"] == "Super users are not allowed to delete themselves" + assert response.status_code == FORBIDDEN_CODE + assert ( + response.json()[ERROR_DETAIL_KEY] + == "Super users are not allowed to delete themselves" + ) def test_delete_user_without_privileges( - client: TestClient, normal_user_token_headers: dict[str, str], db: Session + client: TestClient, + normal_user_token_headers: dict[str, str], + db: Session, ) -> None: - username = random_email() - password = random_lower_string() - user_in = UserCreate(email=username, password=password) - user = crud.create_user(session=db, user_create=user_in) + user = create_user_in_db(db) - r = client.delete( - f"{settings.API_V1_STR}/users/{user.id}", + response = client.delete( + f"{settings.API_V1_STR}{USERS_BASE_ENDPOINT}{user.id}", headers=normal_user_token_headers, ) - assert r.status_code == 403 - assert r.json()["detail"] == "The user doesn't have enough privileges" + assert response.status_code == FORBIDDEN_CODE + assert ( + response.json()[ERROR_DETAIL_KEY] == "The user doesn't have enough privileges" + ) diff --git a/backend/app/tests/conftest.py b/backend/app/tests/conftest.py index 90ab39a357..73e5aaae67 100644 --- a/backend/app/tests/conftest.py +++ b/backend/app/tests/conftest.py @@ -8,26 +8,26 @@ from app.core.db import engine, init_db from app.main import app from app.models import Item, User +from app.tests.utils.test_helpers import get_superuser_token_headers from app.tests.utils.user import authentication_token_from_email -from app.tests.utils.utils import get_superuser_token_headers @pytest.fixture(scope="session", autouse=True) -def db() -> Generator[Session, None, None]: +def db() -> Generator[Session]: with Session(engine) as session: init_db(session) yield session statement = delete(Item) - session.execute(statement) + session.execute(statement) # type: ignore[deprecated] statement = delete(User) - session.execute(statement) + session.execute(statement) # type: ignore[deprecated] session.commit() @pytest.fixture(scope="module") -def client() -> Generator[TestClient, None, None]: - with TestClient(app) as c: - yield c +def client() -> Generator[TestClient]: + with TestClient(app) as test_client: + yield test_client @pytest.fixture(scope="module") @@ -38,5 +38,7 @@ def superuser_token_headers(client: TestClient) -> dict[str, str]: @pytest.fixture(scope="module") def normal_user_token_headers(client: TestClient, db: Session) -> dict[str, str]: return authentication_token_from_email( - client=client, email=settings.EMAIL_TEST_USER, db=db + client=client, + email=settings.EMAIL_TEST_USER, + db=db, ) diff --git a/backend/app/tests/crud/test_user.py b/backend/app/tests/crud/test_user.py index e9eb4a0391..55aed0d3b2 100644 --- a/backend/app/tests/crud/test_user.py +++ b/backend/app/tests/crud/test_user.py @@ -4,7 +4,7 @@ from app import crud from app.core.security import verify_password from app.models import User, UserCreate, UserUpdate -from app.tests.utils.utils import random_email, random_lower_string +from app.tests.utils.test_helpers import random_email, random_lower_string def test_create_user(db: Session) -> None: @@ -70,10 +70,10 @@ def test_get_user(db: Session) -> None: username = random_email() user_in = UserCreate(email=username, password=password, is_superuser=True) user = crud.create_user(session=db, user_create=user_in) - user_2 = db.get(User, user.id) - assert user_2 - assert user.email == user_2.email - assert jsonable_encoder(user) == jsonable_encoder(user_2) + retrieved_user = db.get(User, user.id) + assert retrieved_user + assert user.email == retrieved_user.email + assert jsonable_encoder(user) == jsonable_encoder(retrieved_user) def test_update_user(db: Session) -> None: @@ -85,7 +85,7 @@ def test_update_user(db: Session) -> None: user_in_update = UserUpdate(password=new_password, is_superuser=True) if user.id is not None: crud.update_user(session=db, db_user=user, user_in=user_in_update) - user_2 = db.get(User, user.id) - assert user_2 - assert user.email == user_2.email - assert verify_password(new_password, user_2.hashed_password) + updated_user = db.get(User, user.id) + assert updated_user + assert user.email == updated_user.email + assert verify_password(new_password, updated_user.hashed_password) diff --git a/backend/app/tests/scripts/test_backend_pre_start.py b/backend/app/tests/scripts/test_backend_pre_start.py index 631690fcf6..dd295763a7 100644 --- a/backend/app/tests/scripts/test_backend_pre_start.py +++ b/backend/app/tests/scripts/test_backend_pre_start.py @@ -10,7 +10,7 @@ def test_init_successful_connection() -> None: session_mock = MagicMock() exec_mock = MagicMock(return_value=True) - session_mock.configure_mock(**{"exec.return_value": exec_mock}) + session_mock.exec.return_value = exec_mock with ( patch("sqlmodel.Session", return_value=session_mock), @@ -20,14 +20,13 @@ def test_init_successful_connection() -> None: ): try: init(engine_mock) - connection_successful = True - except Exception: + except Exception: # noqa: BLE001 connection_successful = False + else: + connection_successful = True - assert ( - connection_successful - ), "The database connection should be successful and not raise an exception." + assert connection_successful, ( + "The database connection should be successful and not raise an exception." + ) - assert session_mock.exec.called_once_with( - select(1) - ), "The session should execute a select statement once." + session_mock.exec.assert_called_once_with(select(1)) diff --git a/backend/app/tests/scripts/test_test_pre_start.py b/backend/app/tests/scripts/test_test_pre_start.py index a176f380de..1c9b8d7195 100644 --- a/backend/app/tests/scripts/test_test_pre_start.py +++ b/backend/app/tests/scripts/test_test_pre_start.py @@ -10,7 +10,7 @@ def test_init_successful_connection() -> None: session_mock = MagicMock() exec_mock = MagicMock(return_value=True) - session_mock.configure_mock(**{"exec.return_value": exec_mock}) + session_mock.exec.return_value = exec_mock with ( patch("sqlmodel.Session", return_value=session_mock), @@ -20,14 +20,13 @@ def test_init_successful_connection() -> None: ): try: init(engine_mock) - connection_successful = True - except Exception: + except Exception: # noqa: BLE001 connection_successful = False + else: + connection_successful = True - assert ( - connection_successful - ), "The database connection should be successful and not raise an exception." + assert connection_successful, ( + "The database connection should be successful and not raise an exception." + ) - assert session_mock.exec.called_once_with( - select(1) - ), "The session should execute a select statement once." + session_mock.exec.assert_called_once_with(select(1)) diff --git a/backend/app/tests/utils/item.py b/backend/app/tests/utils/item.py index 6e32b3a84a..4bf3c2227e 100644 --- a/backend/app/tests/utils/item.py +++ b/backend/app/tests/utils/item.py @@ -2,8 +2,8 @@ from app import crud from app.models import Item, ItemCreate +from app.tests.utils.test_helpers import random_lower_string from app.tests.utils.user import create_random_user -from app.tests.utils.utils import random_lower_string def create_random_item(db: Session) -> Item: diff --git a/backend/app/tests/utils/utils.py b/backend/app/tests/utils/test_helpers.py similarity index 56% rename from backend/app/tests/utils/utils.py rename to backend/app/tests/utils/test_helpers.py index 184bac44d9..d6e99db682 100644 --- a/backend/app/tests/utils/utils.py +++ b/backend/app/tests/utils/test_helpers.py @@ -3,11 +3,12 @@ from fastapi.testclient import TestClient +from app.constants import TOKEN_LENGTH from app.core.config import settings def random_lower_string() -> str: - return "".join(random.choices(string.ascii_lowercase, k=32)) + return "".join(random.choices(string.ascii_lowercase, k=TOKEN_LENGTH)) def random_email() -> str: @@ -19,8 +20,7 @@ def get_superuser_token_headers(client: TestClient) -> dict[str, str]: "username": settings.FIRST_SUPERUSER, "password": settings.FIRST_SUPERUSER_PASSWORD, } - r = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data) - tokens = r.json() - a_token = tokens["access_token"] - headers = {"Authorization": f"Bearer {a_token}"} - return headers + response = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data) + response_data = response.json() + access_token = response_data["access_token"] + return {"Authorization": f"Bearer {access_token}"} diff --git a/backend/app/tests/utils/user.py b/backend/app/tests/utils/user.py index 9c1b073109..83c0864f62 100644 --- a/backend/app/tests/utils/user.py +++ b/backend/app/tests/utils/user.py @@ -4,46 +4,47 @@ from app import crud from app.core.config import settings from app.models import User, UserCreate, UserUpdate -from app.tests.utils.utils import random_email, random_lower_string +from app.tests.utils.test_helpers import random_email, random_lower_string def user_authentication_headers( - *, client: TestClient, email: str, password: str + *, + client: TestClient, + email: str, + password: str, ) -> dict[str, str]: - data = {"username": email, "password": password} + login_data = {"username": email, "password": password} - r = client.post(f"{settings.API_V1_STR}/login/access-token", data=data) - response = r.json() - auth_token = response["access_token"] - headers = {"Authorization": f"Bearer {auth_token}"} - return headers + response = client.post(f"{settings.API_V1_STR}/login/access-token", data=login_data) + response_data = response.json() + auth_token = response_data["access_token"] + return {"Authorization": f"Bearer {auth_token}"} def create_random_user(db: Session) -> User: email = random_email() password = random_lower_string() user_in = UserCreate(email=email, password=password) - user = crud.create_user(session=db, user_create=user_in) - return user + return crud.create_user(session=db, user_create=user_in) def authentication_token_from_email( - *, client: TestClient, email: str, db: Session + *, + client: TestClient, + email: str, + db: Session, ) -> dict[str, str]: - """ - Return a valid token for the user with given email. + """Return a valid token for the user with given email. If the user doesn't exist it is created first. """ password = random_lower_string() user = crud.get_user_by_email(session=db, email=email) - if not user: - user_in_create = UserCreate(email=email, password=password) - user = crud.create_user(session=db, user_create=user_in_create) - else: + if user: user_in_update = UserUpdate(password=password) - if not user.id: - raise Exception("User id not set") user = crud.update_user(session=db, db_user=user, user_in=user_in_update) + else: + user_in_create = UserCreate(email=email, password=password) + user = crud.create_user(session=db, user_create=user_in_create) return user_authentication_headers(client=client, email=email, password=password) diff --git a/backend/app/tests_pre_start.py b/backend/app/tests_pre_start.py index 0ce6045635..3ccf0e0a37 100644 --- a/backend/app/tests_pre_start.py +++ b/backend/app/tests_pre_start.py @@ -1,3 +1,5 @@ +"""Pre-start tests to ensure database connectivity.""" + import logging from sqlalchemy import Engine @@ -17,19 +19,21 @@ stop=stop_after_attempt(max_tries), wait=wait_fixed(wait_seconds), before=before_log(logger, logging.INFO), - after=after_log(logger, logging.WARN), + after=after_log(logger, logging.WARNING), ) def init(db_engine: Engine) -> None: + """Initialize database connection with retry logic.""" try: # Try to create session to check if DB is awake with Session(db_engine) as session: session.exec(select(1)) - except Exception as e: - logger.error(e) - raise e + except Exception: + logger.exception("Database connection failed") + raise def main() -> None: + """Initialize database connectivity check.""" logger.info("Initializing service") init(engine) logger.info("Service finished initializing") diff --git a/backend/pyproject.toml b/backend/pyproject.toml index d72454c28a..62fce8397a 100644 --- a/backend/pyproject.toml +++ b/backend/pyproject.toml @@ -36,45 +36,3 @@ dev-dependencies = [ [build-system] requires = ["hatchling"] build-backend = "hatchling.build" - -[tool.mypy] -strict = true -exclude = ["venv", ".venv", "alembic"] - -[tool.ruff] -target-version = "py310" -exclude = ["alembic"] - -[tool.ruff.lint] -select = [ - "E", # pycodestyle errors - "W", # pycodestyle warnings - "F", # pyflakes - "I", # isort - "B", # flake8-bugbear - "C4", # flake8-comprehensions - "UP", # pyupgrade - "ARG001", # unused arguments in functions - "T201", # print statements are not allowed -] -ignore = [ - "E501", # line too long, handled by black - "B008", # do not perform function calls in argument defaults - "W191", # indentation contains tabs - "B904", # Allow raising exceptions without from e, for HTTPException -] - -[tool.ruff.lint.pyupgrade] -# Preserve types, even if a file imports `from __future__ import annotations`. -keep-runtime-typing = true - -[tool.coverage.run] -source = ["app"] -dynamic_context = "test_function" - -[tool.coverage.report] -show_missing = true -sort = "-Cover" - -[tool.coverage.html] -show_contexts = true diff --git a/code_quality_analysis.ipynb b/code_quality_analysis.ipynb new file mode 100644 index 0000000000..ad5ea29c21 --- /dev/null +++ b/code_quality_analysis.ipynb @@ -0,0 +1,1129 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d67b0279", + "metadata": {}, + "source": [ + "# Code Quality Analysis Dashboard\n", + "\n", + "This notebook runs various code quality tools on the backend/ directory and visualizes the results:\n", + "\n", + "- **Bandit**: Security vulnerability scanner\n", + "- **Ruff**: Fast Python linter\n", + "- **MyPy**: Static type checker\n", + "- **Radon CC**: Cyclomatic complexity analyzer\n", + "- **Radon MI**: Maintainability index calculator\n", + "- **Flake8 WPS**: Wemake Python Styleguide checker\n", + "\n", + "## Metrics to Analyze:\n", + "1. Error counts by tool and severity\n", + "2. Error type distribution\n", + "3. Code complexity metrics\n", + "4. Maintainability scores\n", + "5. Security vulnerability patterns" + ] + }, + { + "cell_type": "markdown", + "id": "8c57a1e6", + "metadata": {}, + "source": [ + "## Import Required Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "871ae97e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Libraries imported successfully with high-resolution plotting configuration!\n" + ] + } + ], + "source": [ + "import subprocess\n", + "import json\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import re\n", + "from pathlib import Path\n", + "from collections import defaultdict, Counter\n", + "import warnings\n", + "import numpy as np\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "# Set up plotting style with high-resolution settings\n", + "plt.style.use('seaborn-v0_8')\n", + "sns.set_palette(\"husl\")\n", + "\n", + "# High-resolution plot configuration\n", + "plt.rcParams['figure.figsize'] = (12, 8)\n", + "plt.rcParams['figure.dpi'] = 150 # High DPI for crisp plots\n", + "plt.rcParams['savefig.dpi'] = 300 # High DPI for saved figures\n", + "plt.rcParams['font.size'] = 10\n", + "plt.rcParams['axes.linewidth'] = 1.2\n", + "plt.rcParams['grid.linewidth'] = 0.8\n", + "plt.rcParams['lines.linewidth'] = 2\n", + "plt.rcParams['patch.linewidth'] = 0.5\n", + "plt.rcParams['xtick.major.width'] = 1.2\n", + "plt.rcParams['ytick.major.width'] = 1.2\n", + "plt.rcParams['xtick.minor.width'] = 0.8\n", + "plt.rcParams['ytick.minor.width'] = 0.8\n", + "plt.rcParams['text.antialiased'] = True\n", + "plt.rcParams['figure.facecolor'] = 'white'\n", + "plt.rcParams['axes.facecolor'] = 'white'\n", + "\n", + "print(\"Libraries imported successfully with high-resolution plotting configuration!\")" + ] + }, + { + "cell_type": "markdown", + "id": "a4dfe910", + "metadata": {}, + "source": [ + "## Define Code Quality Tools and Commands" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "f8c53333", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Analyzing directory: /Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend\n", + "Tools configured:\n", + " - bandit: bandit -c pyproject.toml -r backend/ -f json\n", + " - ruff: ruff check backend/ --output-format json\n", + " - mypy: mypy backend/\n", + " - radon_cc: radon cc backend/ -j\n", + " - radon_mi: radon mi backend/ -j\n", + " - flake8_wps: flake8 --select=WPS backend/ --format=json\n" + ] + } + ], + "source": [ + "# Define the backend directory path\n", + "BACKEND_DIR = \"backend/\"\n", + "\n", + "# Define commands for each tool\n", + "TOOLS_COMMANDS = {\n", + " 'bandit': ['bandit', '-c', 'pyproject.toml', '-r', BACKEND_DIR, '-f', 'json'],\n", + " 'ruff': ['ruff', 'check', BACKEND_DIR, '--output-format', 'json'],\n", + " 'mypy': ['mypy', BACKEND_DIR],\n", + " 'radon_cc': ['radon', 'cc', BACKEND_DIR, '-j'],\n", + " 'radon_mi': ['radon', 'mi', BACKEND_DIR, '-j'],\n", + " 'flake8_wps': ['flake8', '--select=WPS', BACKEND_DIR, '--format=json']\n", + "}\n", + "\n", + "print(f\"Analyzing directory: {Path(BACKEND_DIR).absolute()}\")\n", + "print(\"Tools configured:\")\n", + "for tool, cmd in TOOLS_COMMANDS.items():\n", + " print(f\" - {tool}: {' '.join(cmd)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "e198d7ac", + "metadata": {}, + "source": [ + "## Run Bandit Security Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c55d109f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Bandit found 2 security issues\n", + "\n", + "Bandit Results Summary:\n", + "severity confidence\n", + "LOW MEDIUM 2\n", + "dtype: int64\n" + ] + } + ], + "source": [ + "def run_bandit():\n", + " \"\"\"Run bandit security analysis and return parsed results.\"\"\"\n", + " try:\n", + " result = subprocess.run(\n", + " TOOLS_COMMANDS['bandit'], \n", + " capture_output=True, \n", + " text=True, \n", + " cwd=Path.cwd()\n", + " )\n", + " \n", + " if result.stdout:\n", + " bandit_data = json.loads(result.stdout)\n", + " issues = bandit_data.get('results', [])\n", + " \n", + " bandit_df = pd.DataFrame([\n", + " {\n", + " 'tool': 'bandit',\n", + " 'file': issue['filename'],\n", + " 'line': issue['line_number'],\n", + " 'severity': issue['issue_severity'],\n", + " 'confidence': issue['issue_confidence'],\n", + " 'test_id': issue['test_id'],\n", + " 'test_name': issue['test_name'],\n", + " 'message': issue['issue_text']\n", + " }\n", + " for issue in issues\n", + " ])\n", + " \n", + " print(f\"Bandit found {len(bandit_df)} security issues\")\n", + " return bandit_df\n", + " else:\n", + " print(\"Bandit: No issues found\")\n", + " return pd.DataFrame()\n", + " \n", + " except Exception as e:\n", + " print(f\"Error running bandit: {e}\")\n", + " return pd.DataFrame()\n", + "\n", + "bandit_results = run_bandit()\n", + "if not bandit_results.empty:\n", + " print(\"\\nBandit Results Summary:\")\n", + " print(bandit_results.groupby(['severity', 'confidence']).size())" + ] + }, + { + "cell_type": "markdown", + "id": "de0a68e3", + "metadata": {}, + "source": [ + "## Run Ruff Linting" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "0db8c239", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ruff found 0 linting issues\n" + ] + } + ], + "source": [ + "def run_ruff():\n", + " \"\"\"Run ruff linter and return parsed results.\"\"\"\n", + " try:\n", + " result = subprocess.run(\n", + " TOOLS_COMMANDS['ruff'], \n", + " capture_output=True, \n", + " text=True, \n", + " cwd=Path.cwd()\n", + " )\n", + " \n", + " if result.stdout:\n", + " ruff_data = json.loads(result.stdout)\n", + " \n", + " ruff_df = pd.DataFrame([\n", + " {\n", + " 'tool': 'ruff',\n", + " 'file': issue['filename'],\n", + " 'line': issue['location']['row'],\n", + " 'column': issue['location']['column'],\n", + " 'rule_code': issue['code'],\n", + " 'rule_name': issue['message'],\n", + " 'message': issue['message'],\n", + " 'severity': 'error' if issue.get('fix') else 'warning'\n", + " }\n", + " for issue in ruff_data\n", + " ])\n", + " \n", + " print(f\"Ruff found {len(ruff_df)} linting issues\")\n", + " return ruff_df\n", + " else:\n", + " print(\"Ruff: No issues found\")\n", + " return pd.DataFrame()\n", + " \n", + " except Exception as e:\n", + " print(f\"Error running ruff: {e}\")\n", + " return pd.DataFrame()\n", + "\n", + "ruff_results = run_ruff()\n", + "if not ruff_results.empty:\n", + " print(\"\\nRuff Results Summary:\")\n", + " print(\"Top 10 most common rules:\")\n", + " print(ruff_results['rule_code'].value_counts().head(10))" + ] + }, + { + "cell_type": "markdown", + "id": "788a98b2", + "metadata": {}, + "source": [ + "## Run MyPy Type Checking" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "2a1f0732", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MyPy found 0 type checking issues\n" + ] + } + ], + "source": [ + "def run_mypy():\n", + " \"\"\"Run mypy type checker and return parsed results.\"\"\"\n", + " try:\n", + " result = subprocess.run(\n", + " TOOLS_COMMANDS['mypy'], \n", + " capture_output=True, \n", + " text=True, \n", + " cwd=Path.cwd()\n", + " )\n", + " \n", + " if result.stdout:\n", + " lines = result.stdout.strip().split('\\n')\n", + " mypy_issues = []\n", + " \n", + " for line in lines:\n", + " if ':' in line and ('error:' in line or 'warning:' in line or 'note:' in line):\n", + " parts = line.split(':')\n", + " if len(parts) >= 4:\n", + " file_path = parts[0]\n", + " line_num = parts[1] if parts[1].isdigit() else '0'\n", + " severity = 'error' if 'error:' in line else 'warning' if 'warning:' in line else 'note'\n", + " message = ':'.join(parts[3:]).strip()\n", + " \n", + " mypy_issues.append({\n", + " 'tool': 'mypy',\n", + " 'file': file_path,\n", + " 'line': int(line_num),\n", + " 'severity': severity,\n", + " 'message': message\n", + " })\n", + " \n", + " mypy_df = pd.DataFrame(mypy_issues)\n", + " print(f\"MyPy found {len(mypy_df)} type checking issues\")\n", + " return mypy_df\n", + " else:\n", + " print(\"MyPy: No issues found\")\n", + " return pd.DataFrame()\n", + " \n", + " except Exception as e:\n", + " print(f\"Error running mypy: {e}\")\n", + " return pd.DataFrame()\n", + "\n", + "mypy_results = run_mypy()\n", + "if not mypy_results.empty:\n", + " print(\"\\nMyPy Results Summary:\")\n", + " print(mypy_results['severity'].value_counts())" + ] + }, + { + "cell_type": "markdown", + "id": "d289413f", + "metadata": {}, + "source": [ + "## Run Radon Cyclomatic Complexity Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b0cf9e3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Radon CC analyzed 162 functions/methods (all ranks included)\n", + "\n", + "Radon CC Results Summary:\n", + "Average complexity: 2.33\n", + "Complexity rank distribution:\n", + "rank\n", + "A 156\n", + "B 6\n", + "Name: count, dtype: int64\n", + "[1 6 2 3 5 4 8 7]\n" + ] + } + ], + "source": [ + "def run_radon_cc():\n", + " \"\"\"Run radon cyclomatic complexity analysis and return parsed results (all ranks).\"\"\"\n", + " try:\n", + " result = subprocess.run(\n", + " TOOLS_COMMANDS['radon_cc'], \n", + " capture_output=True, \n", + " text=True, \n", + " cwd=Path.cwd()\n", + " )\n", + " \n", + " if result.stdout:\n", + " cc_data = json.loads(result.stdout)\n", + " cc_issues = []\n", + " \n", + " for file_path, functions in cc_data.items():\n", + " for func in functions:\n", + " cc_issues.append({\n", + " 'tool': 'radon_cc',\n", + " 'file': file_path,\n", + " 'function': func['name'],\n", + " 'line': func['lineno'],\n", + " 'complexity': func['complexity'],\n", + " 'rank': func['rank'],\n", + " 'type': func['type']\n", + " })\n", + " \n", + " cc_df = pd.DataFrame(cc_issues)\n", + " print(f\"Radon CC analyzed {len(cc_df)} functions/methods (all ranks included)\")\n", + " return cc_df\n", + " else:\n", + " print(\"Radon CC: No data found\")\n", + " return pd.DataFrame()\n", + " \n", + " except Exception as e:\n", + " print(f\"Error running radon cc: {e}\")\n", + " return pd.DataFrame()\n", + "\n", + "radon_cc_results = run_radon_cc()\n", + "if not radon_cc_results.empty:\n", + " print(\"\\nRadon CC Results Summary:\")\n", + " print(f\"Average complexity: {radon_cc_results['complexity'].mean():.2f}\")\n", + " print(\"Complexity rank distribution:\")\n", + " print(radon_cc_results['rank'].value_counts().sort_index())" + ] + }, + { + "cell_type": "markdown", + "id": "2dc96586", + "metadata": {}, + "source": [ + "## Run Radon Maintainability Index Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "6820f645", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Radon MI analyzed 46 files (all ranks included)\n", + "\n", + "Radon MI Results Summary:\n", + "Average maintainability index: 81.39\n", + "MI rank distribution:\n", + "mi_rank\n", + "A 46\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "def run_radon_mi():\n", + " \"\"\"Run radon maintainability index analysis and return parsed results (all ranks).\"\"\"\n", + " try:\n", + " result = subprocess.run(\n", + " TOOLS_COMMANDS['radon_mi'], \n", + " capture_output=True, \n", + " text=True, \n", + " cwd=Path.cwd()\n", + " )\n", + " \n", + " if result.stdout:\n", + " mi_data = json.loads(result.stdout)\n", + " mi_issues = []\n", + " \n", + " for file_path, mi_info in mi_data.items():\n", + " mi_issues.append({\n", + " 'tool': 'radon_mi',\n", + " 'file': file_path,\n", + " 'mi_score': mi_info['mi'],\n", + " 'mi_rank': mi_info['rank']\n", + " })\n", + " \n", + " mi_df = pd.DataFrame(mi_issues)\n", + " print(f\"Radon MI analyzed {len(mi_df)} files (all ranks included)\")\n", + " return mi_df\n", + " else:\n", + " print(\"Radon MI: No data found\")\n", + " return pd.DataFrame()\n", + " \n", + " except Exception as e:\n", + " print(f\"Error running radon mi: {e}\")\n", + " return pd.DataFrame()\n", + "\n", + "radon_mi_results = run_radon_mi()\n", + "if not radon_mi_results.empty:\n", + " print(\"\\nRadon MI Results Summary:\")\n", + " print(f\"Average maintainability index: {radon_mi_results['mi_score'].mean():.2f}\")\n", + " print(\"MI rank distribution:\")\n", + " print(radon_mi_results['mi_rank'].value_counts().sort_index())" + ] + }, + { + "cell_type": "markdown", + "id": "c231aca4", + "metadata": {}, + "source": [ + "## Run Flake8 with WPS Plugin" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "e3918fd3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Flake8 WPS found 3 style issues\n", + "\n", + "Flake8 WPS Results Summary:\n", + "Top 10 most common WPS rules:\n", + "rule_code\n", + "WPS202 3\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "def run_flake8_wps():\n", + " \"\"\"Run flake8 with WPS plugin and return parsed results.\"\"\"\n", + " try:\n", + " # Try with regular flake8 output format since json might not be available\n", + " result = subprocess.run(\n", + " ['flake8', '--select=WPS', BACKEND_DIR], \n", + " capture_output=True, \n", + " text=True, \n", + " cwd=Path.cwd()\n", + " )\n", + " \n", + " if result.stdout:\n", + " lines = result.stdout.strip().split('\\n')\n", + " flake8_issues = []\n", + " \n", + " for line in lines:\n", + " if line.strip():\n", + " # Parse flake8 output format: file:line:column: code message\n", + " parts = line.split(':')\n", + " if len(parts) >= 4:\n", + " file_path = parts[0]\n", + " line_num = parts[1] if parts[1].isdigit() else '0'\n", + " column = parts[2] if parts[2].isdigit() else '0'\n", + " \n", + " # Extract error code and message\n", + " error_part = ':'.join(parts[3:]).strip()\n", + " error_match = re.match(r'\\s*(WPS\\d+)\\s+(.+)', error_part)\n", + " if error_match:\n", + " error_code = error_match.group(1)\n", + " message = error_match.group(2)\n", + " \n", + " flake8_issues.append({\n", + " 'tool': 'flake8_wps',\n", + " 'file': file_path,\n", + " 'line': int(line_num),\n", + " 'column': int(column),\n", + " 'rule_code': error_code,\n", + " 'message': message,\n", + " 'severity': 'warning'\n", + " })\n", + " \n", + " flake8_df = pd.DataFrame(flake8_issues)\n", + " print(f\"Flake8 WPS found {len(flake8_df)} style issues\")\n", + " return flake8_df\n", + " else:\n", + " print(\"Flake8 WPS: No issues found\")\n", + " return pd.DataFrame()\n", + " \n", + " except Exception as e:\n", + " print(f\"Error running flake8 WPS: {e}\")\n", + " print(\"Note: Make sure wemake-python-styleguide is installed\")\n", + " return pd.DataFrame()\n", + "\n", + "flake8_wps_results = run_flake8_wps()\n", + "if not flake8_wps_results.empty:\n", + " print(\"\\nFlake8 WPS Results Summary:\")\n", + " print(\"Top 10 most common WPS rules:\")\n", + " print(flake8_wps_results['rule_code'].value_counts().head(10))" + ] + }, + { + "cell_type": "markdown", + "id": "02928a92", + "metadata": {}, + "source": [ + "## Parse and Aggregate Results" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "d122b78a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== SUMMARY STATISTICS (Radon A ranks excluded from counts) ===\n", + " total_issues files_analyzed\n", + "bandit 2 2\n", + "ruff 0 0\n", + "mypy 0 0\n", + "radon_cc 6 3\n", + "radon_mi 0 0\n", + "flake8_wps 3 3\n", + "\n", + "Total combined issues (excluding Radon A ranks): 11\n" + ] + } + ], + "source": [ + "# Aggregate all results for visualization\n", + "all_results = {\n", + " 'bandit': bandit_results,\n", + " 'ruff': ruff_results,\n", + " 'mypy': mypy_results,\n", + " 'radon_cc': radon_cc_results,\n", + " 'radon_mi': radon_mi_results,\n", + " 'flake8_wps': flake8_wps_results\n", + "}\n", + "\n", + "# Prepare filtered copies for issue counting (exclude non-issues: rank A for radon metrics)\n", + "issue_results = {}\n", + "for tool, df in all_results.items():\n", + " if df is None or df.empty:\n", + " issue_results[tool] = df\n", + " continue\n", + " if tool == 'radon_cc':\n", + " issue_results[tool] = df[df['rank'] != 'A'] # exclude excellent complexity\n", + " elif tool == 'radon_mi':\n", + " issue_results[tool] = df[df['mi_rank'] != 'A'] # exclude excellent maintainability\n", + " else:\n", + " issue_results[tool] = df\n", + "\n", + "# Calculate summary statistics using issue_results\n", + "summary_stats = {}\n", + "for tool, df in issue_results.items():\n", + " summary_stats[tool] = {\n", + " 'total_issues': len(df) if df is not None else 0,\n", + " 'files_analyzed': df['file'].nunique() if df is not None and not df.empty and 'file' in df.columns else 0\n", + " }\n", + "\n", + "print(\"\\n=== SUMMARY STATISTICS (Radon A ranks excluded from counts) ===\")\n", + "summary_df = pd.DataFrame(summary_stats).T\n", + "print(summary_df)\n", + "\n", + "# Create a combined issues dataframe for common fields (using issue_results)\n", + "issue_dfs = []\n", + "for tool, df in issue_results.items():\n", + " if df is not None and not df.empty and 'file' in df.columns:\n", + " issue_df = df[['tool', 'file']].copy()\n", + " if 'line' in df.columns:\n", + " issue_df['line'] = df['line']\n", + " if 'severity' in df.columns:\n", + " issue_df['severity'] = df['severity']\n", + " elif tool == 'radon_cc' and 'rank' in df.columns:\n", + " issue_df['severity'] = df['rank']\n", + " elif tool == 'radon_mi' and 'mi_rank' in df.columns:\n", + " issue_df['severity'] = df['mi_rank']\n", + " else:\n", + " issue_df['severity'] = 'info'\n", + " issue_dfs.append(issue_df)\n", + "\n", + "if issue_dfs:\n", + " combined_issues = pd.concat(issue_dfs, ignore_index=True)\n", + " print(f\"\\nTotal combined issues (excluding Radon A ranks): {len(combined_issues)}\")\n", + "else:\n", + " combined_issues = pd.DataFrame()\n", + " print(\"\\nNo issues found to analyze\")" + ] + }, + { + "cell_type": "markdown", + "id": "87fda3aa", + "metadata": {}, + "source": [ + "## Create Error Count Visualizations" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "7b178a7f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create visualizations with high-resolution settings\n", + "fig, axes = plt.subplots(2, 2, figsize=(16, 12), dpi=150)\n", + "fig.suptitle('Code Quality Analysis Dashboard', fontsize=18, fontweight='bold', y=0.98)\n", + "\n", + "# 1. Total issues by tool\n", + "tools = list(summary_stats.keys())\n", + "issue_counts = [summary_stats[tool]['total_issues'] for tool in tools]\n", + "\n", + "axes[0, 0].bar(tools, issue_counts, color=sns.color_palette(\"husl\", len(tools)))\n", + "axes[0, 0].set_title('Total Issues by Tool')\n", + "axes[0, 0].set_ylabel('Number of Issues')\n", + "axes[0, 0].tick_params(axis='x', rotation=45)\n", + "\n", + "# Add value labels on bars\n", + "for i, v in enumerate(issue_counts):\n", + " axes[0, 0].text(i, v + 0.5, str(v), ha='center', va='bottom')\n", + "\n", + "# 2. Files analyzed by tool\n", + "files_analyzed = [summary_stats[tool]['files_analyzed'] for tool in tools]\n", + "axes[0, 1].bar(tools, files_analyzed, color=sns.color_palette(\"husl\", len(tools)))\n", + "axes[0, 1].set_title('Files Analyzed by Tool')\n", + "axes[0, 1].set_ylabel('Number of Files')\n", + "axes[0, 1].tick_params(axis='x', rotation=45)\n", + "\n", + "for i, v in enumerate(files_analyzed):\n", + " axes[0, 1].text(i, v + 0.1, str(v), ha='center', va='bottom')\n", + "\n", + "# 3. Severity distribution (if we have combined issues)\n", + "if not combined_issues.empty:\n", + " severity_counts = combined_issues['severity'].value_counts()\n", + " axes[1, 0].pie(severity_counts.values, labels=severity_counts.index, autopct='%1.1f%%')\n", + " axes[1, 0].set_title('Issue Severity Distribution')\n", + "else:\n", + " axes[1, 0].text(0.5, 0.5, 'No severity data available', ha='center', va='center', transform=axes[1, 0].transAxes)\n", + " axes[1, 0].set_title('Issue Severity Distribution')\n", + "\n", + "# 4. Issues per file (top 10 files with most issues)\n", + "if not combined_issues.empty:\n", + " file_issues = combined_issues['file'].value_counts().head(10)\n", + " if not file_issues.empty:\n", + " # Truncate long file paths for better display\n", + " short_names = [Path(f).name for f in file_issues.index]\n", + " axes[1, 1].barh(range(len(file_issues)), file_issues.values)\n", + " axes[1, 1].set_yticks(range(len(file_issues)))\n", + " axes[1, 1].set_yticklabels(short_names)\n", + " axes[1, 1].set_title('Top 10 Files with Most Issues')\n", + " axes[1, 1].set_xlabel('Number of Issues')\n", + " else:\n", + " axes[1, 1].text(0.5, 0.5, 'No file data available', ha='center', va='center', transform=axes[1, 1].transAxes)\n", + " axes[1, 1].set_title('Issues per File')\n", + "else:\n", + " axes[1, 1].text(0.5, 0.5, 'No file data available', ha='center', va='center', transform=axes[1, 1].transAxes)\n", + " axes[1, 1].set_title('Issues per File')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0f590f37", + "metadata": {}, + "source": [ + "## Create Error Type Distribution Charts" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "f8c74802", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 3, figsize=(18, 12), dpi=150)\n", + "# fig.suptitle('Error Type Distribution by Tool', fontsize=18, fontweight='bold', y=0.96)\n", + "\n", + "# Bandit severity distribution\n", + "if not bandit_results.empty:\n", + " bandit_severity = bandit_results['severity'].value_counts()\n", + " axes[0, 0].pie(bandit_severity.values, labels=bandit_severity.index, autopct='%1.1f%%')\n", + " axes[0, 0].set_title(f'Bandit Issues by Severity\\n(Total: {len(bandit_results)})')\n", + "else:\n", + " axes[0, 0].text(0.5, 0.5, 'No Bandit issues', ha='center', va='center', transform=axes[0, 0].transAxes)\n", + " axes[0, 0].set_title('Bandit Issues by Severity')\n", + "\n", + "# Ruff rule types\n", + "if not ruff_results.empty:\n", + " # Extract rule categories (first letter of rule code)\n", + " ruff_results['rule_category'] = ruff_results['rule_code'].str[0]\n", + " ruff_categories = ruff_results['rule_category'].value_counts().head(8)\n", + " axes[0, 1].bar(ruff_categories.index, ruff_categories.values)\n", + " axes[0, 1].set_title(f'Ruff Rule Categories\\n(Total: {len(ruff_results)})')\n", + " axes[0, 1].set_ylabel('Number of Issues')\n", + "else:\n", + " axes[0, 1].text(0.5, 0.5, 'No Ruff issues', ha='center', va='center', transform=axes[0, 1].transAxes)\n", + " axes[0, 1].set_title('Ruff Rule Categories')\n", + "\n", + "# MyPy issue types\n", + "if not mypy_results.empty:\n", + " mypy_severity = mypy_results['severity'].value_counts()\n", + " axes[0, 2].pie(mypy_severity.values, labels=mypy_severity.index, autopct='%1.1f%%')\n", + " axes[0, 2].set_title(f'MyPy Issues by Severity\\n(Total: {len(mypy_results)})')\n", + "else:\n", + " axes[0, 2].text(0.5, 0.5, 'No MyPy issues', ha='center', va='center', transform=axes[0, 2].transAxes)\n", + " axes[0, 2].set_title('MyPy Issues by Severity')\n", + "\n", + "# Radon CC complexity distribution\n", + "if not radon_cc_results.empty:\n", + " axes[1, 0].hist(radon_cc_results['complexity'], bins=20, alpha=0.7, color='skyblue', edgecolor='black')\n", + " axes[1, 0].set_title('Cyclomatic Complexity Distribution\\n(Score less is better)')\n", + " axes[1, 0].set_xlabel('Complexity Score')\n", + " axes[1, 0].set_ylabel('Frequency')\n", + " axes[1, 0].axvline(radon_cc_results['complexity'].mean(), color='red', linestyle='--', label=f\"Mean: {radon_cc_results['complexity'].mean():.1f}\")\n", + " axes[1, 0].legend()\n", + "else:\n", + " axes[1, 0].text(0.5, 0.5, 'No complexity data', ha='center', va='center', transform=axes[1, 0].transAxes)\n", + " axes[1, 0].set_title('Cyclomatic Complexity Distribution')\n", + "\n", + "# Radon MI maintainability distribution\n", + "if not radon_mi_results.empty:\n", + " axes[1, 1].hist(radon_mi_results['mi_score'], bins=15, alpha=0.7, color='lightgreen', edgecolor='black')\n", + " axes[1, 1].set_title('Maintainability Index Distribution\\n(Score higher is better)')\n", + " axes[1, 1].set_xlabel('MI Score')\n", + " axes[1, 1].set_ylabel('Frequency')\n", + " axes[1, 1].axvline(radon_mi_results['mi_score'].mean(), color='red', linestyle='--', label=f\"Mean: {radon_mi_results['mi_score'].mean():.1f}\")\n", + " axes[1, 1].legend()\n", + "else:\n", + " axes[1, 1].text(0.5, 0.5, 'No MI data', ha='center', va='center', transform=axes[1, 1].transAxes)\n", + " axes[1, 1].set_title('Maintainability Index Distribution')\n", + "\n", + "# Flake8 WPS rule types\n", + "if not flake8_wps_results.empty:\n", + " # Group WPS rules by hundreds (WPS100, WPS200, etc.)\n", + " flake8_wps_results['rule_group'] = flake8_wps_results['rule_code'].str.extract(r'(WPS\\d{1})')\n", + " wps_groups = flake8_wps_results['rule_group'].value_counts().head(8)\n", + " axes[1, 2].bar(wps_groups.index, wps_groups.values)\n", + " axes[1, 2].set_title(f'Flake8 WPS Rule Groups\\n(Total: {len(flake8_wps_results)})')\n", + " axes[1, 2].set_ylabel('Number of Issues')\n", + " axes[1, 2].tick_params(axis='x', rotation=45)\n", + "else:\n", + " axes[1, 2].text(0.5, 0.5, 'No WPS issues', ha='center', va='center', transform=axes[1, 2].transAxes)\n", + " axes[1, 2].set_title('Flake8 WPS Rule Groups')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7f1ace1e", + "metadata": {}, + "source": [ + "## Generate Complexity Metrics Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "982f835e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create detailed complexity analysis\n", + "fig, axes = plt.subplots(2, 2, figsize=(16, 12), dpi=150)\n", + "fig.suptitle('Code Complexity Analysis', fontsize=18, fontweight='bold', y=0.96)\n", + "\n", + "# Cyclomatic Complexity Box Plot by Rank\n", + "if not radon_cc_results.empty:\n", + " sns.boxplot(data=radon_cc_results, x='rank', y='complexity', ax=axes[0, 0])\n", + " axes[0, 0].set_title('Complexity Distribution by Rank')\n", + " axes[0, 0].set_xlabel('Complexity Rank')\n", + " axes[0, 0].set_ylabel('Complexity Score')\n", + "else:\n", + " axes[0, 0].text(0.5, 0.5, 'No complexity data', ha='center', va='center', transform=axes[0, 0].transAxes)\n", + " axes[0, 0].set_title('Complexity Distribution by Rank')\n", + "\n", + "# Maintainability Index vs Complexity (if both available)\n", + "if not radon_cc_results.empty and not radon_mi_results.empty:\n", + " # Merge CC and MI data by file\n", + " cc_by_file = radon_cc_results.groupby('file')['complexity'].mean().reset_index()\n", + " mi_by_file = radon_mi_results[['file', 'mi_score']].copy()\n", + " \n", + " merged = pd.merge(cc_by_file, mi_by_file, on='file', how='inner')\n", + " \n", + " if not merged.empty:\n", + " axes[0, 1].scatter(merged['complexity'], merged['mi_score'], alpha=0.6)\n", + " axes[0, 1].set_xlabel('Average Complexity')\n", + " axes[0, 1].set_ylabel('Maintainability Index')\n", + " axes[0, 1].set_title('Complexity vs Maintainability')\n", + " \n", + " # Add trend line\n", + " z = np.polyfit(merged['complexity'], merged['mi_score'], 1)\n", + " p = np.poly1d(z)\n", + " axes[0, 1].plot(merged['complexity'], p(merged['complexity']), \"r--\", alpha=0.8)\n", + " else:\n", + " axes[0, 1].text(0.5, 0.5, 'No matching files', ha='center', va='center', transform=axes[0, 1].transAxes)\n", + " axes[0, 1].set_title('Complexity vs Maintainability')\n", + "else:\n", + " axes[0, 1].text(0.5, 0.5, 'Insufficient data', ha='center', va='center', transform=axes[0, 1].transAxes)\n", + " axes[0, 1].set_title('Complexity vs Maintainability')\n", + "\n", + "# Function type distribution in complexity\n", + "if not radon_cc_results.empty:\n", + " func_type_counts = radon_cc_results['type'].value_counts()\n", + " axes[1, 0].pie(func_type_counts.values, labels=func_type_counts.index, autopct='%1.1f%%')\n", + " axes[1, 0].set_title('Function Types Distribution')\n", + "else:\n", + " axes[1, 0].text(0.5, 0.5, 'No function data', ha='center', va='center', transform=axes[1, 0].transAxes)\n", + " axes[1, 0].set_title('Function Types Distribution')\n", + "\n", + "# Top 10 most complex functions\n", + "if not radon_cc_results.empty:\n", + " top_complex = radon_cc_results.nlargest(10, 'complexity')\n", + " \n", + " # Create shorter labels for function names\n", + " labels = [f\"{Path(row['file']).name}:{row['function']}\" for _, row in top_complex.iterrows()]\n", + " short_labels = [label[:30] + '...' if len(label) > 30 else label for label in labels]\n", + " \n", + " y_pos = range(len(top_complex))\n", + " axes[1, 1].barh(y_pos, top_complex['complexity'])\n", + " axes[1, 1].set_yticks(y_pos)\n", + " axes[1, 1].set_yticklabels(short_labels, fontsize=8)\n", + " axes[1, 1].set_xlabel('Complexity Score')\n", + " axes[1, 1].set_title('Top 10 Most Complex Functions')\n", + "else:\n", + " axes[1, 1].text(0.5, 0.5, 'No function data', ha='center', va='center', transform=axes[1, 1].transAxes)\n", + " axes[1, 1].set_title('Top 10 Most Complex Functions')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8c491fb2", + "metadata": {}, + "source": [ + "## Create Summary Dashboard" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "9f184293", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "================================================================================\n", + "CODE QUALITY ANALYSIS SUMMARY\n", + "================================================================================\n", + "Note: Radon cyclomatic complexity and maintainability entries with rank 'A' are treated as non-issues and excluded from issue counts while still used in distribution plots.\n", + "\n", + "📊 OVERALL METRICS:\n", + " Total Issues Found (excluding Radon A ranks): 11\n", + " Files Analyzed (max across tools): 3\n", + " Average Issues per File: 3.67\n", + "\n", + "🔍 TOOL BREAKDOWN:\n", + " BANDIT: 2 issues across 2 files\n", + " RUFF: 0 issues across 0 files\n", + " MYPY: 0 issues across 0 files\n", + " RADON_CC: 6 issues across 3 files\n", + " RADON_MI: 0 issues across 0 files\n", + " FLAKE8_WPS: 3 issues across 3 files\n", + "\n", + "💡 QUALITY INSIGHTS:\n", + " 🚨 Security: 0 high-severity security issues found\n", + " 🔄 Complexity: Average CC (all ranks) = 2.33, 0 functions with CC > 10\n", + " 🛠️ Maintainability: Average MI (all ranks) = 81.39, 0 files with MI < 20 (needs attention)\n", + "\n", + "📋 RECOMMENDATIONS:\n", + " 1. Address 11 total issues found across all tools\n", + " 2. Security: Review and fix 2 security issues\n", + "\n", + "================================================================================\n", + "\n", + "FINAL SUMMARY TABLE:\n", + " Tool Total Issues (A excl) Files Analyzed Issues per File\n", + " bandit 2 2 1.0\n", + " ruff 0 0 0.0\n", + " mypy 0 0 0.0\n", + " radon_cc 6 3 2.0\n", + " radon_mi 0 0 0.0\n", + "flake8_wps 3 3 1.0\n", + "\n", + "💾 Results saved to 'code_quality_summary.csv'\n", + "💾 Detailed issues saved to 'detailed_issues.csv'\n" + ] + } + ], + "source": [ + "# Create a comprehensive summary\n", + "print(\"\\n\" + \"=\"*80)\n", + "print(\"CODE QUALITY ANALYSIS SUMMARY\")\n", + "print(\"=\"*80)\n", + "print(\"Note: Radon cyclomatic complexity and maintainability entries with rank 'A' are treated as non-issues and excluded from issue counts while still used in distribution plots.\")\n", + "\n", + "# Overall statistics\n", + "total_issues = sum(summary_stats[tool]['total_issues'] for tool in summary_stats)\n", + "files_with_any = [summary_stats[tool]['files_analyzed'] for tool in summary_stats if summary_stats[tool]['files_analyzed'] > 0]\n", + "total_files = max(files_with_any) if files_with_any else 0\n", + "\n", + "print(f\"\\n📊 OVERALL METRICS:\")\n", + "print(f\" Total Issues Found (excluding Radon A ranks): {total_issues}\")\n", + "print(f\" Files Analyzed (max across tools): {total_files}\")\n", + "print(f\" Average Issues per File: {total_issues/total_files:.2f}\" if total_files > 0 else \" Average Issues per File: N/A\")\n", + "\n", + "# Tool-specific summaries\n", + "print(f\"\\n🔍 TOOL BREAKDOWN:\")\n", + "for tool, stats in summary_stats.items():\n", + " print(f\" {tool.upper()}: {stats['total_issues']} issues across {stats['files_analyzed']} files\")\n", + "\n", + "# Quality insights\n", + "print(f\"\\n💡 QUALITY INSIGHTS:\")\n", + "\n", + "if not bandit_results.empty:\n", + " high_severity = len(bandit_results[bandit_results['severity'] == 'HIGH'])\n", + " print(f\" 🚨 Security: {high_severity} high-severity security issues found\")\n", + "\n", + "if not radon_cc_results.empty:\n", + " avg_complexity = radon_cc_results['complexity'].mean()\n", + " high_complexity = len(radon_cc_results[radon_cc_results['complexity'] > 10])\n", + " print(f\" 🔄 Complexity: Average CC (all ranks) = {avg_complexity:.2f}, {high_complexity} functions with CC > 10\")\n", + "\n", + "if not radon_mi_results.empty:\n", + " avg_mi = radon_mi_results['mi_score'].mean()\n", + " low_mi = len(radon_mi_results[radon_mi_results['mi_score'] < 20])\n", + " print(f\" 🛠️ Maintainability: Average MI (all ranks) = {avg_mi:.2f}, {low_mi} files with MI < 20 (needs attention)\")\n", + "\n", + "# Recommendations\n", + "print(f\"\\n📋 RECOMMENDATIONS:\")\n", + "\n", + "if total_issues == 0:\n", + " print(\" ✅ Excellent! No issues found by any tool (after excluding A rank Radon entries).\")\n", + "else:\n", + " print(f\" 1. Address {total_issues} total issues found across all tools\")\n", + " \n", + " if not bandit_results.empty:\n", + " print(f\" 2. Security: Review and fix {len(bandit_results)} security issues\")\n", + " \n", + " if not radon_cc_results.empty and radon_cc_results['complexity'].max() > 15:\n", + " print(f\" 3. Complexity: Refactor functions with complexity > 15\")\n", + " \n", + " if not radon_mi_results.empty and radon_mi_results['mi_score'].min() < 10:\n", + " print(f\" 4. Maintainability: Improve files with MI < 10\")\n", + " \n", + " if not ruff_results.empty:\n", + " top_ruff_rule = ruff_results['rule_code'].value_counts().index[0]\n", + " print(f\" 5. Style: Focus on fixing {top_ruff_rule} rule violations first\")\n", + "\n", + "print(\"\\n\" + \"=\"*80)\n", + "\n", + "# Create final summary table\n", + "summary_table = pd.DataFrame({\n", + " 'Tool': list(summary_stats.keys()),\n", + " 'Total Issues (A excl)': [summary_stats[tool]['total_issues'] for tool in summary_stats],\n", + " 'Files Analyzed': [summary_stats[tool]['files_analyzed'] for tool in summary_stats],\n", + " 'Issues per File': [summary_stats[tool]['total_issues']/max(summary_stats[tool]['files_analyzed'], 1) for tool in summary_stats]\n", + "})\n", + "\n", + "print(\"\\nFINAL SUMMARY TABLE:\")\n", + "print(summary_table.to_string(index=False))\n", + "\n", + "# Save results to CSV for further analysis\n", + "summary_table.to_csv('code_quality_summary.csv', index=False)\n", + "print(\"\\n💾 Results saved to 'code_quality_summary.csv'\")\n", + "\n", + "if not combined_issues.empty:\n", + " combined_issues.to_csv('detailed_issues.csv', index=False)\n", + " print(\"💾 Detailed issues saved to 'detailed_issues.csv'\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40749cdc", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fastapi-moscow-python-demo (3.12.10)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000000..d70073eb7d --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,104 @@ +[project] +name = "fastapi-moscow-python-demo" +version = "0.1.0" +description = "Add your description here" +readme = "README.md" +requires-python = ">=3.12" +dependencies = [ + "alembic>=1.16.5", + "bandit>=1.8.6", + "fastapi>=0.116.1", + "flake8>=7.3.0", + "ipykernel>=6.30.1", + "jinja2>=3.1.6", + "matplotlib>=3.10.6", + "mypy>=1.17.1", + "numpy>=2.3.3", + "pandas>=2.3.2", + "passlib>=1.7.4", + "pydantic-settings>=2.10.1", + "pyjwt>=2.10.1", + "pytest>=8.4.2", + "radon>=6.0.1", + "ruff>=0.13.0", + "seaborn>=0.13.2", + "sqlalchemy>=2.0.43", + "sqlmodel>=0.0.24", + "tenacity>=9.1.2", + "types-passlib>=1.7.7.20250602", + "wemake-python-styleguide>=1.4.0", +] + +[tool.mypy] +# Core strictness +strict = true +extra_checks = true # opt-in stricter checks beyond --strict +warn_unreachable = true # not included in --strict; catch dead/ redundant code +implicit_reexport = false # require explicit re-exports (no implicit module exports) +local_partial_types = true # force annotations for top-level/class partial types +strict_equality = true # prohibit always-false/true comparisons + +# Be ruthless about Any +disallow_any_unimported = true +disallow_any_decorated = true +disallow_any_explicit = true +disallow_any_generics = true +disallow_subclassing_any = true + +# No untyped or half-typed defs/calls +disallow_untyped_calls = true +disallow_untyped_defs = true +disallow_incomplete_defs = true + +# Hygiene & signal +warn_return_any = true +warn_redundant_casts = true +warn_unused_ignores = true +show_error_codes = true + +# Optional error codes that make reviews sharper +enable_error_code = [ + "ignore-without-code", # every `# type: ignore` must be specific + "redundant-expr", # flag obviously redundant boolean logic + "possibly-undefined", # variables not defined on all paths + "truthy-bool", # questionable truthiness checks + "truthy-iterable", # questionable truthiness checks on iterables + "deprecated", # use of @deprecated (PEP 702 / typing_extensions) + "exhaustive-match" # non-exhaustive `match` on enums / unions (where supported) +] + +# Optional: make the default on recent mypy explicit (safer across versions) +implicit_optional = false + +[tool.ruff] +target-version = "py313" +exclude = ["hooks", "frontend"] + +[tool.ruff.lint] +select = ["ALL"] +external = [ "WPS" ] +ignore = [ + "D104", # Ignore missing docstrings in packages +] + +[tool.ruff.lint.extend-per-file-ignores] +"backend/app/tests/**/*.py" = [ + # at least this three should be fine in tests: + "S101", # asserts allowed in tests... + "ARG", # Unused function args -> fixtures nevertheless are functionally relevant... + "FBT", # Don't care about booleans as positional arguments in tests, e.g. via @pytest.mark.parametrize() + # The below are debateable + "PLR2004", # Magic value used in comparison, ... + "S311", # Standard pseudo-random generators are not suitable for cryptographic purposes + "D103", # Ignore missing docstrings in tests + "D100", # Ignore missing docstrings in public modules +] + +[tool.flake8] +per-file-ignores = [ + "backend/app/tests/*.py: WPS432", + "backend/app/alembic/**/*.py: WPS", +] + +[tool.bandit] +exclude_dirs = ["app/tests"] diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 0000000000..c5ffc2d2b9 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,5 @@ +[flake8] +extend-ignore = WPS115,WPS332 +per-file-ignores = + backend/app/tests/*.py: WPS432,WPS218,WPS204,WPS202,WPS210,WPS226,WPS221 + backend/app/alembic/**/*.py: WPS \ No newline at end of file diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000000..1870f9bf0a --- /dev/null +++ b/uv.lock @@ -0,0 +1,1624 @@ +version = 1 +revision = 3 +requires-python = ">=3.12" + +[[package]] +name = "alembic" +version = "1.16.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mako" }, + { name = "sqlalchemy" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9a/ca/4dc52902cf3491892d464f5265a81e9dff094692c8a049a3ed6a05fe7ee8/alembic-1.16.5.tar.gz", hash = "sha256:a88bb7f6e513bd4301ecf4c7f2206fe93f9913f9b48dac3b78babde2d6fe765e", size = 1969868, upload-time = "2025-08-27T18:02:05.668Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/4a/4c61d4c84cfd9befb6fa08a702535b27b21fff08c946bc2f6139decbf7f7/alembic-1.16.5-py3-none-any.whl", hash = "sha256:e845dfe090c5ffa7b92593ae6687c5cb1a101e91fa53868497dbd79847f9dbe3", size = 247355, upload-time = "2025-08-27T18:02:07.37Z" }, +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, +] + +[[package]] +name = "anyio" +version = "4.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "sniffio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f1/b4/636b3b65173d3ce9a38ef5f0522789614e590dab6a8d505340a4efe4c567/anyio-4.10.0.tar.gz", hash = "sha256:3f3fae35c96039744587aa5b8371e7e8e603c0702999535961dd336026973ba6", size = 213252, upload-time = "2025-08-04T08:54:26.451Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6f/12/e5e0282d673bb9746bacfb6e2dba8719989d3660cdb2ea79aee9a9651afb/anyio-4.10.0-py3-none-any.whl", hash = "sha256:60e474ac86736bbfd6f210f7a61218939c318f43f9972497381f1c5e930ed3d1", size = 107213, upload-time = "2025-08-04T08:54:24.882Z" }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978, upload-time = "2024-11-30T04:30:14.439Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918, upload-time = "2024-11-30T04:30:10.946Z" }, +] + +[[package]] +name = "attrs" +version = "25.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/b0/1367933a8532ee6ff8d63537de4f1177af4bff9f3e829baf7331f595bb24/attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b", size = 812032, upload-time = "2025-03-13T11:10:22.779Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815, upload-time = "2025-03-13T11:10:21.14Z" }, +] + +[[package]] +name = "bandit" +version = "1.8.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "pyyaml" }, + { name = "rich" }, + { name = "stevedore" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/b5/7eb834e213d6f73aace21938e5e90425c92e5f42abafaf8a6d5d21beed51/bandit-1.8.6.tar.gz", hash = "sha256:dbfe9c25fc6961c2078593de55fd19f2559f9e45b99f1272341f5b95dea4e56b", size = 4240271, upload-time = "2025-07-06T03:10:50.9Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/ca/ba5f909b40ea12ec542d5d7bdd13ee31c4d65f3beed20211ef81c18fa1f3/bandit-1.8.6-py3-none-any.whl", hash = "sha256:3348e934d736fcdb68b6aa4030487097e23a501adf3e7827b63658df464dddd0", size = 133808, upload-time = "2025-07-06T03:10:49.134Z" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "debugpy" +version = "1.8.16" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/d4/722d0bcc7986172ac2ef3c979ad56a1030e3afd44ced136d45f8142b1f4a/debugpy-1.8.16.tar.gz", hash = "sha256:31e69a1feb1cf6b51efbed3f6c9b0ef03bc46ff050679c4be7ea6d2e23540870", size = 1643809, upload-time = "2025-08-06T18:00:02.647Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/fb/0387c0e108d842c902801bc65ccc53e5b91d8c169702a9bbf4f7efcedf0c/debugpy-1.8.16-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:b202e2843e32e80b3b584bcebfe0e65e0392920dc70df11b2bfe1afcb7a085e4", size = 2511822, upload-time = "2025-08-06T18:00:18.526Z" }, + { url = "https://files.pythonhosted.org/packages/37/44/19e02745cae22bf96440141f94e15a69a1afaa3a64ddfc38004668fcdebf/debugpy-1.8.16-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64473c4a306ba11a99fe0bb14622ba4fbd943eb004847d9b69b107bde45aa9ea", size = 4230135, upload-time = "2025-08-06T18:00:19.997Z" }, + { url = "https://files.pythonhosted.org/packages/f3/0b/19b1ba5ee4412f303475a2c7ad5858efb99c90eae5ec627aa6275c439957/debugpy-1.8.16-cp312-cp312-win32.whl", hash = "sha256:833a61ed446426e38b0dd8be3e9d45ae285d424f5bf6cd5b2b559c8f12305508", size = 5281271, upload-time = "2025-08-06T18:00:21.281Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e0/bc62e2dc141de53bd03e2c7cb9d7011de2e65e8bdcdaa26703e4d28656ba/debugpy-1.8.16-cp312-cp312-win_amd64.whl", hash = "sha256:75f204684581e9ef3dc2f67687c3c8c183fde2d6675ab131d94084baf8084121", size = 5323149, upload-time = "2025-08-06T18:00:23.033Z" }, + { url = "https://files.pythonhosted.org/packages/62/66/607ab45cc79e60624df386e233ab64a6d8d39ea02e7f80e19c1d451345bb/debugpy-1.8.16-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:85df3adb1de5258dca910ae0bb185e48c98801ec15018a263a92bb06be1c8787", size = 2496157, upload-time = "2025-08-06T18:00:24.361Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a0/c95baae08a75bceabb79868d663a0736655e427ab9c81fb848da29edaeac/debugpy-1.8.16-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bee89e948bc236a5c43c4214ac62d28b29388453f5fd328d739035e205365f0b", size = 4222491, upload-time = "2025-08-06T18:00:25.806Z" }, + { url = "https://files.pythonhosted.org/packages/5b/2f/1c8db6ddd8a257c3cd2c46413b267f1d5fa3df910401c899513ce30392d6/debugpy-1.8.16-cp313-cp313-win32.whl", hash = "sha256:cf358066650439847ec5ff3dae1da98b5461ea5da0173d93d5e10f477c94609a", size = 5281126, upload-time = "2025-08-06T18:00:27.207Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ba/c3e154ab307366d6c5a9c1b68de04914e2ce7fa2f50d578311d8cc5074b2/debugpy-1.8.16-cp313-cp313-win_amd64.whl", hash = "sha256:b5aea1083f6f50023e8509399d7dc6535a351cc9f2e8827d1e093175e4d9fa4c", size = 5323094, upload-time = "2025-08-06T18:00:29.03Z" }, + { url = "https://files.pythonhosted.org/packages/52/57/ecc9ae29fa5b2d90107cd1d9bf8ed19aacb74b2264d986ae9d44fe9bdf87/debugpy-1.8.16-py2.py3-none-any.whl", hash = "sha256:19c9521962475b87da6f673514f7fd610328757ec993bf7ec0d8c96f9a325f9e", size = 5287700, upload-time = "2025-08-06T18:00:42.333Z" }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, +] + +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, +] + +[[package]] +name = "fastapi" +version = "0.116.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/78/d7/6c8b3bfe33eeffa208183ec037fee0cce9f7f024089ab1c5d12ef04bd27c/fastapi-0.116.1.tar.gz", hash = "sha256:ed52cbf946abfd70c5a0dccb24673f0670deeb517a88b3544d03c2a6bf283143", size = 296485, upload-time = "2025-07-11T16:22:32.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/47/d63c60f59a59467fda0f93f46335c9d18526d7071f025cb5b89d5353ea42/fastapi-0.116.1-py3-none-any.whl", hash = "sha256:c46ac7c312df840f0c9e220f7964bada936781bc4e2e6eb71f1c4d7553786565", size = 95631, upload-time = "2025-07-11T16:22:30.485Z" }, +] + +[[package]] +name = "fastapi-moscow-python-demo" +version = "0.1.0" +source = { virtual = "." } +dependencies = [ + { name = "alembic" }, + { name = "bandit" }, + { name = "fastapi" }, + { name = "flake8" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "matplotlib" }, + { name = "mypy" }, + { name = "numpy" }, + { name = "pandas" }, + { name = "passlib" }, + { name = "pydantic-settings" }, + { name = "pyjwt" }, + { name = "pytest" }, + { name = "radon" }, + { name = "ruff" }, + { name = "seaborn" }, + { name = "sqlalchemy" }, + { name = "sqlmodel" }, + { name = "tenacity" }, + { name = "types-passlib" }, + { name = "wemake-python-styleguide" }, +] + +[package.metadata] +requires-dist = [ + { name = "alembic", specifier = ">=1.16.5" }, + { name = "bandit", specifier = ">=1.8.6" }, + { name = "fastapi", specifier = ">=0.116.1" }, + { name = "flake8", specifier = ">=7.3.0" }, + { name = "ipykernel", specifier = ">=6.30.1" }, + { name = "jinja2", specifier = ">=3.1.6" }, + { name = "matplotlib", specifier = ">=3.10.6" }, + { name = "mypy", specifier = ">=1.17.1" }, + { name = "numpy", specifier = ">=2.3.3" }, + { name = "pandas", specifier = ">=2.3.2" }, + { name = "passlib", specifier = ">=1.7.4" }, + { name = "pydantic-settings", specifier = ">=2.10.1" }, + { name = "pyjwt", specifier = ">=2.10.1" }, + { name = "pytest", specifier = ">=8.4.2" }, + { name = "radon", specifier = ">=6.0.1" }, + { name = "ruff", specifier = ">=0.13.0" }, + { name = "seaborn", specifier = ">=0.13.2" }, + { name = "sqlalchemy", specifier = ">=2.0.43" }, + { name = "sqlmodel", specifier = ">=0.0.24" }, + { name = "tenacity", specifier = ">=9.1.2" }, + { name = "types-passlib", specifier = ">=1.7.7.20250602" }, + { name = "wemake-python-styleguide", specifier = ">=1.4.0" }, +] + +[[package]] +name = "flake8" +version = "7.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mccabe" }, + { name = "pycodestyle" }, + { name = "pyflakes" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9b/af/fbfe3c4b5a657d79e5c47a2827a362f9e1b763336a52f926126aa6dc7123/flake8-7.3.0.tar.gz", hash = "sha256:fe044858146b9fc69b551a4b490d69cf960fcb78ad1edcb84e7fbb1b4a8e3872", size = 48326, upload-time = "2025-06-20T19:31:35.838Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/56/13ab06b4f93ca7cac71078fbe37fcea175d3216f31f85c3168a6bbd0bb9a/flake8-7.3.0-py2.py3-none-any.whl", hash = "sha256:b9696257b9ce8beb888cdbe31cf885c90d31928fe202be0889a7cdafad32f01e", size = 57922, upload-time = "2025-06-20T19:31:34.425Z" }, +] + +[[package]] +name = "fonttools" +version = "4.59.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0d/a5/fba25f9fbdab96e26dedcaeeba125e5f05a09043bf888e0305326e55685b/fonttools-4.59.2.tar.gz", hash = "sha256:e72c0749b06113f50bcb80332364c6be83a9582d6e3db3fe0b280f996dc2ef22", size = 3540889, upload-time = "2025-08-27T16:40:30.97Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ba/3d/1f45db2df51e7bfa55492e8f23f383d372200be3a0ded4bf56a92753dd1f/fonttools-4.59.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:82906d002c349cad647a7634b004825a7335f8159d0d035ae89253b4abf6f3ea", size = 2769711, upload-time = "2025-08-27T16:39:04.423Z" }, + { url = "https://files.pythonhosted.org/packages/29/df/cd236ab32a8abfd11558f296e064424258db5edefd1279ffdbcfd4fd8b76/fonttools-4.59.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a10c1bd7644dc58f8862d8ba0cf9fb7fef0af01ea184ba6ce3f50ab7dfe74d5a", size = 2340225, upload-time = "2025-08-27T16:39:06.143Z" }, + { url = "https://files.pythonhosted.org/packages/98/12/b6f9f964fe6d4b4dd4406bcbd3328821c3de1f909ffc3ffa558fe72af48c/fonttools-4.59.2-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:738f31f23e0339785fd67652a94bc69ea49e413dfdb14dcb8c8ff383d249464e", size = 4912766, upload-time = "2025-08-27T16:39:08.138Z" }, + { url = "https://files.pythonhosted.org/packages/73/78/82bde2f2d2c306ef3909b927363170b83df96171f74e0ccb47ad344563cd/fonttools-4.59.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ec99f9bdfee9cdb4a9172f9e8fd578cce5feb231f598909e0aecf5418da4f25", size = 4955178, upload-time = "2025-08-27T16:39:10.094Z" }, + { url = "https://files.pythonhosted.org/packages/92/77/7de766afe2d31dda8ee46d7e479f35c7d48747e558961489a2d6e3a02bd4/fonttools-4.59.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0476ea74161322e08c7a982f83558a2b81b491509984523a1a540baf8611cc31", size = 4897898, upload-time = "2025-08-27T16:39:12.087Z" }, + { url = "https://files.pythonhosted.org/packages/c5/77/ce0e0b905d62a06415fda9f2b2e109a24a5db54a59502b769e9e297d2242/fonttools-4.59.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:95922a922daa1f77cc72611747c156cfb38030ead72436a2c551d30ecef519b9", size = 5049144, upload-time = "2025-08-27T16:39:13.84Z" }, + { url = "https://files.pythonhosted.org/packages/d9/ea/870d93aefd23fff2e07cbeebdc332527868422a433c64062c09d4d5e7fe6/fonttools-4.59.2-cp312-cp312-win32.whl", hash = "sha256:39ad9612c6a622726a6a130e8ab15794558591f999673f1ee7d2f3d30f6a3e1c", size = 2206473, upload-time = "2025-08-27T16:39:15.854Z" }, + { url = "https://files.pythonhosted.org/packages/61/c4/e44bad000c4a4bb2e9ca11491d266e857df98ab6d7428441b173f0fe2517/fonttools-4.59.2-cp312-cp312-win_amd64.whl", hash = "sha256:980fd7388e461b19a881d35013fec32c713ffea1fc37aef2f77d11f332dfd7da", size = 2254706, upload-time = "2025-08-27T16:39:17.893Z" }, + { url = "https://files.pythonhosted.org/packages/13/7b/d0d3b9431642947b5805201fbbbe938a47b70c76685ef1f0cb5f5d7140d6/fonttools-4.59.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:381bde13216ba09489864467f6bc0c57997bd729abfbb1ce6f807ba42c06cceb", size = 2761563, upload-time = "2025-08-27T16:39:20.286Z" }, + { url = "https://files.pythonhosted.org/packages/76/be/fc5fe58dd76af7127b769b68071dbc32d4b95adc8b58d1d28d42d93c90f2/fonttools-4.59.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f33839aa091f7eef4e9078f5b7ab1b8ea4b1d8a50aeaef9fdb3611bba80869ec", size = 2335671, upload-time = "2025-08-27T16:39:22.027Z" }, + { url = "https://files.pythonhosted.org/packages/f2/9f/bf231c2a3fac99d1d7f1d89c76594f158693f981a4aa02be406e9f036832/fonttools-4.59.2-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6235fc06bcbdb40186f483ba9d5d68f888ea68aa3c8dac347e05a7c54346fbc8", size = 4893967, upload-time = "2025-08-27T16:39:23.664Z" }, + { url = "https://files.pythonhosted.org/packages/26/a9/d46d2ad4fcb915198504d6727f83aa07f46764c64f425a861aa38756c9fd/fonttools-4.59.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:83ad6e5d06ef3a2884c4fa6384a20d6367b5cfe560e3b53b07c9dc65a7020e73", size = 4951986, upload-time = "2025-08-27T16:39:25.379Z" }, + { url = "https://files.pythonhosted.org/packages/07/90/1cc8d7dd8f707dfeeca472b82b898d3add0ebe85b1f645690dcd128ee63f/fonttools-4.59.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d029804c70fddf90be46ed5305c136cae15800a2300cb0f6bba96d48e770dde0", size = 4891630, upload-time = "2025-08-27T16:39:27.494Z" }, + { url = "https://files.pythonhosted.org/packages/d8/04/f0345b0d9fe67d65aa8d3f2d4cbf91d06f111bc7b8d802e65914eb06194d/fonttools-4.59.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:95807a3b5e78f2714acaa26a33bc2143005cc05c0217b322361a772e59f32b89", size = 5035116, upload-time = "2025-08-27T16:39:29.406Z" }, + { url = "https://files.pythonhosted.org/packages/d7/7d/5ba5eefffd243182fbd067cdbfeb12addd4e5aec45011b724c98a344ea33/fonttools-4.59.2-cp313-cp313-win32.whl", hash = "sha256:b3ebda00c3bb8f32a740b72ec38537d54c7c09f383a4cfefb0b315860f825b08", size = 2204907, upload-time = "2025-08-27T16:39:31.42Z" }, + { url = "https://files.pythonhosted.org/packages/ea/a9/be7219fc64a6026cc0aded17fa3720f9277001c185434230bd351bf678e6/fonttools-4.59.2-cp313-cp313-win_amd64.whl", hash = "sha256:a72155928d7053bbde499d32a9c77d3f0f3d29ae72b5a121752481bcbd71e50f", size = 2253742, upload-time = "2025-08-27T16:39:33.079Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c7/486580d00be6fa5d45e41682e5ffa5c809f3d25773c6f39628d60f333521/fonttools-4.59.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:d09e487d6bfbe21195801323ba95c91cb3523f0fcc34016454d4d9ae9eaa57fe", size = 2762444, upload-time = "2025-08-27T16:39:34.759Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9b/950ea9b7b764ceb8d18645c62191e14ce62124d8e05cb32a4dc5e65fde0b/fonttools-4.59.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:dec2f22486d7781087b173799567cffdcc75e9fb2f1c045f05f8317ccce76a3e", size = 2333256, upload-time = "2025-08-27T16:39:40.777Z" }, + { url = "https://files.pythonhosted.org/packages/9b/4d/8ee9d563126de9002eede950cde0051be86cc4e8c07c63eca0c9fc95734a/fonttools-4.59.2-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1647201af10993090120da2e66e9526c4e20e88859f3e34aa05b8c24ded2a564", size = 4834846, upload-time = "2025-08-27T16:39:42.885Z" }, + { url = "https://files.pythonhosted.org/packages/03/26/f26d947b0712dce3d118e92ce30ca88f98938b066498f60d0ee000a892ae/fonttools-4.59.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:47742c33fe65f41eabed36eec2d7313a8082704b7b808752406452f766c573fc", size = 4930871, upload-time = "2025-08-27T16:39:44.818Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/ebe878061a5a5e6b6502f0548489e01100f7e6c0049846e6546ba19a3ab4/fonttools-4.59.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:92ac2d45794f95d1ad4cb43fa07e7e3776d86c83dc4b9918cf82831518165b4b", size = 4876971, upload-time = "2025-08-27T16:39:47.027Z" }, + { url = "https://files.pythonhosted.org/packages/eb/0d/0d22e3a20ac566836098d30718092351935487e3271fd57385db1adb2fde/fonttools-4.59.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:fa9ecaf2dcef8941fb5719e16322345d730f4c40599bbf47c9753de40eb03882", size = 4987478, upload-time = "2025-08-27T16:39:48.774Z" }, + { url = "https://files.pythonhosted.org/packages/3b/a3/960cc83182a408ffacc795e61b5f698c6f7b0cfccf23da4451c39973f3c8/fonttools-4.59.2-cp314-cp314-win32.whl", hash = "sha256:a8d40594982ed858780e18a7e4c80415af65af0f22efa7de26bdd30bf24e1e14", size = 2208640, upload-time = "2025-08-27T16:39:50.592Z" }, + { url = "https://files.pythonhosted.org/packages/d8/74/55e5c57c414fa3965fee5fc036ed23f26a5c4e9e10f7f078a54ff9c7dfb7/fonttools-4.59.2-cp314-cp314-win_amd64.whl", hash = "sha256:9cde8b6a6b05f68516573523f2013a3574cb2c75299d7d500f44de82ba947b80", size = 2258457, upload-time = "2025-08-27T16:39:52.611Z" }, + { url = "https://files.pythonhosted.org/packages/e1/dc/8e4261dc591c5cfee68fecff3ffee2a9b29e1edc4c4d9cbafdc5aefe74ee/fonttools-4.59.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:036cd87a2dbd7ef72f7b68df8314ced00b8d9973aee296f2464d06a836aeb9a9", size = 2829901, upload-time = "2025-08-27T16:39:55.014Z" }, + { url = "https://files.pythonhosted.org/packages/fb/05/331538dcf21fd6331579cd628268150e85210d0d2bdae20f7598c2b36c05/fonttools-4.59.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:14870930181493b1d740b6f25483e20185e5aea58aec7d266d16da7be822b4bb", size = 2362717, upload-time = "2025-08-27T16:39:56.843Z" }, + { url = "https://files.pythonhosted.org/packages/60/ae/d26428ca9ede809c0a93f0af91f44c87433dc0251e2aec333da5ed00d38f/fonttools-4.59.2-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7ff58ea1eb8fc7e05e9a949419f031890023f8785c925b44d6da17a6a7d6e85d", size = 4835120, upload-time = "2025-08-27T16:39:59.06Z" }, + { url = "https://files.pythonhosted.org/packages/07/c4/0f6ac15895de509e07688cb1d45f1ae583adbaa0fa5a5699d73f3bd58ca0/fonttools-4.59.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6dee142b8b3096514c96ad9e2106bf039e2fe34a704c587585b569a36df08c3c", size = 5071115, upload-time = "2025-08-27T16:40:01.009Z" }, + { url = "https://files.pythonhosted.org/packages/b2/b6/147a711b7ecf7ea39f9da9422a55866f6dd5747c2f36b3b0a7a7e0c6820b/fonttools-4.59.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8991bdbae39cf78bcc9cd3d81f6528df1f83f2e7c23ccf6f990fa1f0b6e19708", size = 4943905, upload-time = "2025-08-27T16:40:03.179Z" }, + { url = "https://files.pythonhosted.org/packages/5b/4e/2ab19006646b753855e2b02200fa1cabb75faa4eeca4ef289f269a936974/fonttools-4.59.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:53c1a411b7690042535a4f0edf2120096a39a506adeb6c51484a232e59f2aa0c", size = 4960313, upload-time = "2025-08-27T16:40:05.45Z" }, + { url = "https://files.pythonhosted.org/packages/98/3d/df77907e5be88adcca93cc2cee00646d039da220164be12bee028401e1cf/fonttools-4.59.2-cp314-cp314t-win32.whl", hash = "sha256:59d85088e29fa7a8f87d19e97a1beae2a35821ee48d8ef6d2c4f965f26cb9f8a", size = 2269719, upload-time = "2025-08-27T16:40:07.553Z" }, + { url = "https://files.pythonhosted.org/packages/2d/a0/d4c4bc5b50275449a9a908283b567caa032a94505fe1976e17f994faa6be/fonttools-4.59.2-cp314-cp314t-win_amd64.whl", hash = "sha256:7ad5d8d8cc9e43cb438b3eb4a0094dd6d4088daa767b0a24d52529361fd4c199", size = 2333169, upload-time = "2025-08-27T16:40:09.656Z" }, + { url = "https://files.pythonhosted.org/packages/65/a4/d2f7be3c86708912c02571db0b550121caab8cd88a3c0aacb9cfa15ea66e/fonttools-4.59.2-py3-none-any.whl", hash = "sha256:8bd0f759020e87bb5d323e6283914d9bf4ae35a7307dafb2cbd1e379e720ad37", size = 1132315, upload-time = "2025-08-27T16:40:28.984Z" }, +] + +[[package]] +name = "greenlet" +version = "3.2.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/03/b8/704d753a5a45507a7aab61f18db9509302ed3d0a27ac7e0359ec2905b1a6/greenlet-3.2.4.tar.gz", hash = "sha256:0dca0d95ff849f9a364385f36ab49f50065d76964944638be9691e1832e9f86d", size = 188260, upload-time = "2025-08-07T13:24:33.51Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/69/9b804adb5fd0671f367781560eb5eb586c4d495277c93bde4307b9e28068/greenlet-3.2.4-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3b67ca49f54cede0186854a008109d6ee71f66bd57bb36abd6d0a0267b540cdd", size = 274079, upload-time = "2025-08-07T13:15:45.033Z" }, + { url = "https://files.pythonhosted.org/packages/46/e9/d2a80c99f19a153eff70bc451ab78615583b8dac0754cfb942223d2c1a0d/greenlet-3.2.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddf9164e7a5b08e9d22511526865780a576f19ddd00d62f8a665949327fde8bb", size = 640997, upload-time = "2025-08-07T13:42:56.234Z" }, + { url = "https://files.pythonhosted.org/packages/3b/16/035dcfcc48715ccd345f3a93183267167cdd162ad123cd93067d86f27ce4/greenlet-3.2.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f28588772bb5fb869a8eb331374ec06f24a83a9c25bfa1f38b6993afe9c1e968", size = 655185, upload-time = "2025-08-07T13:45:27.624Z" }, + { url = "https://files.pythonhosted.org/packages/31/da/0386695eef69ffae1ad726881571dfe28b41970173947e7c558d9998de0f/greenlet-3.2.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:5c9320971821a7cb77cfab8d956fa8e39cd07ca44b6070db358ceb7f8797c8c9", size = 649926, upload-time = "2025-08-07T13:53:15.251Z" }, + { url = "https://files.pythonhosted.org/packages/68/88/69bf19fd4dc19981928ceacbc5fd4bb6bc2215d53199e367832e98d1d8fe/greenlet-3.2.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c60a6d84229b271d44b70fb6e5fa23781abb5d742af7b808ae3f6efd7c9c60f6", size = 651839, upload-time = "2025-08-07T13:18:30.281Z" }, + { url = "https://files.pythonhosted.org/packages/19/0d/6660d55f7373b2ff8152401a83e02084956da23ae58cddbfb0b330978fe9/greenlet-3.2.4-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b3812d8d0c9579967815af437d96623f45c0f2ae5f04e366de62a12d83a8fb0", size = 607586, upload-time = "2025-08-07T13:18:28.544Z" }, + { url = "https://files.pythonhosted.org/packages/8e/1a/c953fdedd22d81ee4629afbb38d2f9d71e37d23caace44775a3a969147d4/greenlet-3.2.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:abbf57b5a870d30c4675928c37278493044d7c14378350b3aa5d484fa65575f0", size = 1123281, upload-time = "2025-08-07T13:42:39.858Z" }, + { url = "https://files.pythonhosted.org/packages/3f/c7/12381b18e21aef2c6bd3a636da1088b888b97b7a0362fac2e4de92405f97/greenlet-3.2.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:20fb936b4652b6e307b8f347665e2c615540d4b42b3b4c8a321d8286da7e520f", size = 1151142, upload-time = "2025-08-07T13:18:22.981Z" }, + { url = "https://files.pythonhosted.org/packages/e9/08/b0814846b79399e585f974bbeebf5580fbe59e258ea7be64d9dfb253c84f/greenlet-3.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:a7d4e128405eea3814a12cc2605e0e6aedb4035bf32697f72deca74de4105e02", size = 299899, upload-time = "2025-08-07T13:38:53.448Z" }, + { url = "https://files.pythonhosted.org/packages/49/e8/58c7f85958bda41dafea50497cbd59738c5c43dbbea5ee83d651234398f4/greenlet-3.2.4-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:1a921e542453fe531144e91e1feedf12e07351b1cf6c9e8a3325ea600a715a31", size = 272814, upload-time = "2025-08-07T13:15:50.011Z" }, + { url = "https://files.pythonhosted.org/packages/62/dd/b9f59862e9e257a16e4e610480cfffd29e3fae018a68c2332090b53aac3d/greenlet-3.2.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd3c8e693bff0fff6ba55f140bf390fa92c994083f838fece0f63be121334945", size = 641073, upload-time = "2025-08-07T13:42:57.23Z" }, + { url = "https://files.pythonhosted.org/packages/f7/0b/bc13f787394920b23073ca3b6c4a7a21396301ed75a655bcb47196b50e6e/greenlet-3.2.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:710638eb93b1fa52823aa91bf75326f9ecdfd5e0466f00789246a5280f4ba0fc", size = 655191, upload-time = "2025-08-07T13:45:29.752Z" }, + { url = "https://files.pythonhosted.org/packages/f2/d6/6adde57d1345a8d0f14d31e4ab9c23cfe8e2cd39c3baf7674b4b0338d266/greenlet-3.2.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:c5111ccdc9c88f423426df3fd1811bfc40ed66264d35aa373420a34377efc98a", size = 649516, upload-time = "2025-08-07T13:53:16.314Z" }, + { url = "https://files.pythonhosted.org/packages/7f/3b/3a3328a788d4a473889a2d403199932be55b1b0060f4ddd96ee7cdfcad10/greenlet-3.2.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d76383238584e9711e20ebe14db6c88ddcedc1829a9ad31a584389463b5aa504", size = 652169, upload-time = "2025-08-07T13:18:32.861Z" }, + { url = "https://files.pythonhosted.org/packages/ee/43/3cecdc0349359e1a527cbf2e3e28e5f8f06d3343aaf82ca13437a9aa290f/greenlet-3.2.4-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23768528f2911bcd7e475210822ffb5254ed10d71f4028387e5a99b4c6699671", size = 610497, upload-time = "2025-08-07T13:18:31.636Z" }, + { url = "https://files.pythonhosted.org/packages/b8/19/06b6cf5d604e2c382a6f31cafafd6f33d5dea706f4db7bdab184bad2b21d/greenlet-3.2.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:00fadb3fedccc447f517ee0d3fd8fe49eae949e1cd0f6a611818f4f6fb7dc83b", size = 1121662, upload-time = "2025-08-07T13:42:41.117Z" }, + { url = "https://files.pythonhosted.org/packages/a2/15/0d5e4e1a66fab130d98168fe984c509249c833c1a3c16806b90f253ce7b9/greenlet-3.2.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:d25c5091190f2dc0eaa3f950252122edbbadbb682aa7b1ef2f8af0f8c0afefae", size = 1149210, upload-time = "2025-08-07T13:18:24.072Z" }, + { url = "https://files.pythonhosted.org/packages/0b/55/2321e43595e6801e105fcfdee02b34c0f996eb71e6ddffca6b10b7e1d771/greenlet-3.2.4-cp313-cp313-win_amd64.whl", hash = "sha256:554b03b6e73aaabec3745364d6239e9e012d64c68ccd0b8430c64ccc14939a8b", size = 299685, upload-time = "2025-08-07T13:24:38.824Z" }, + { url = "https://files.pythonhosted.org/packages/22/5c/85273fd7cc388285632b0498dbbab97596e04b154933dfe0f3e68156c68c/greenlet-3.2.4-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:49a30d5fda2507ae77be16479bdb62a660fa51b1eb4928b524975b3bde77b3c0", size = 273586, upload-time = "2025-08-07T13:16:08.004Z" }, + { url = "https://files.pythonhosted.org/packages/d1/75/10aeeaa3da9332c2e761e4c50d4c3556c21113ee3f0afa2cf5769946f7a3/greenlet-3.2.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:299fd615cd8fc86267b47597123e3f43ad79c9d8a22bebdce535e53550763e2f", size = 686346, upload-time = "2025-08-07T13:42:59.944Z" }, + { url = "https://files.pythonhosted.org/packages/c0/aa/687d6b12ffb505a4447567d1f3abea23bd20e73a5bed63871178e0831b7a/greenlet-3.2.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:c17b6b34111ea72fc5a4e4beec9711d2226285f0386ea83477cbb97c30a3f3a5", size = 699218, upload-time = "2025-08-07T13:45:30.969Z" }, + { url = "https://files.pythonhosted.org/packages/dc/8b/29aae55436521f1d6f8ff4e12fb676f3400de7fcf27fccd1d4d17fd8fecd/greenlet-3.2.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b4a1870c51720687af7fa3e7cda6d08d801dae660f75a76f3845b642b4da6ee1", size = 694659, upload-time = "2025-08-07T13:53:17.759Z" }, + { url = "https://files.pythonhosted.org/packages/92/2e/ea25914b1ebfde93b6fc4ff46d6864564fba59024e928bdc7de475affc25/greenlet-3.2.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:061dc4cf2c34852b052a8620d40f36324554bc192be474b9e9770e8c042fd735", size = 695355, upload-time = "2025-08-07T13:18:34.517Z" }, + { url = "https://files.pythonhosted.org/packages/72/60/fc56c62046ec17f6b0d3060564562c64c862948c9d4bc8aa807cf5bd74f4/greenlet-3.2.4-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:44358b9bf66c8576a9f57a590d5f5d6e72fa4228b763d0e43fee6d3b06d3a337", size = 657512, upload-time = "2025-08-07T13:18:33.969Z" }, + { url = "https://files.pythonhosted.org/packages/e3/a5/6ddab2b4c112be95601c13428db1d8b6608a8b6039816f2ba09c346c08fc/greenlet-3.2.4-cp314-cp314-win_amd64.whl", hash = "sha256:e37ab26028f12dbb0ff65f29a8d3d44a765c61e729647bf2ddfbbed621726f01", size = 303425, upload-time = "2025-08-07T13:32:27.59Z" }, +] + +[[package]] +name = "idna" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793, upload-time = "2025-03-19T20:09:59.721Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" }, +] + +[[package]] +name = "ipykernel" +version = "6.30.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/76/11082e338e0daadc89c8ff866185de11daf67d181901038f9e139d109761/ipykernel-6.30.1.tar.gz", hash = "sha256:6abb270161896402e76b91394fcdce5d1be5d45f456671e5080572f8505be39b", size = 166260, upload-time = "2025-08-04T15:47:35.018Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/c7/b445faca8deb954fe536abebff4ece5b097b923de482b26e78448c89d1dd/ipykernel-6.30.1-py3-none-any.whl", hash = "sha256:aa6b9fb93dca949069d8b85b6c79b2518e32ac583ae9c7d37c51d119e18b3fb4", size = 117484, upload-time = "2025-08-04T15:47:32.622Z" }, +] + +[[package]] +name = "ipython" +version = "9.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6e/71/a86262bf5a68bf211bcc71fe302af7e05f18a2852fdc610a854d20d085e6/ipython-9.5.0.tar.gz", hash = "sha256:129c44b941fe6d9b82d36fc7a7c18127ddb1d6f02f78f867f402e2e3adde3113", size = 4389137, upload-time = "2025-08-29T12:15:21.519Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/2a/5628a99d04acb2d2f2e749cdf4ea571d2575e898df0528a090948018b726/ipython-9.5.0-py3-none-any.whl", hash = "sha256:88369ffa1d5817d609120daa523a6da06d02518e582347c29f8451732a9c5e72", size = 612426, upload-time = "2025-08-29T12:15:18.866Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019, upload-time = "2024-09-17T10:44:17.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105, upload-time = "2024-09-17T10:44:15.218Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.8.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/1b/72906d554acfeb588332eaaa6f61577705e9ec752ddb486f302dafa292d9/jupyter_core-5.8.1.tar.gz", hash = "sha256:0a5f9706f70e64786b75acba995988915ebd4601c8a52e534a40b51c95f59941", size = 88923, upload-time = "2025-05-27T07:38:16.655Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/57/6bffd4b20b88da3800c5d691e0337761576ee688eb01299eae865689d2df/jupyter_core-5.8.1-py3-none-any.whl", hash = "sha256:c28d268fc90fb53f1338ded2eb410704c5449a358406e8a948b75706e24863d0", size = 28880, upload-time = "2025-05-27T07:38:15.137Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5c/3c/85844f1b0feb11ee581ac23fe5fce65cd049a200c1446708cc1b7f922875/kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d", size = 97564, upload-time = "2025-08-10T21:27:49.279Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/c9/13573a747838aeb1c76e3267620daa054f4152444d1f3d1a2324b78255b5/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ac5a486ac389dddcc5bef4f365b6ae3ffff2c433324fb38dd35e3fab7c957999", size = 123686, upload-time = "2025-08-10T21:26:10.034Z" }, + { url = "https://files.pythonhosted.org/packages/51/ea/2ecf727927f103ffd1739271ca19c424d0e65ea473fbaeea1c014aea93f6/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2ba92255faa7309d06fe44c3a4a97efe1c8d640c2a79a5ef728b685762a6fd2", size = 66460, upload-time = "2025-08-10T21:26:11.083Z" }, + { url = "https://files.pythonhosted.org/packages/5b/5a/51f5464373ce2aeb5194508298a508b6f21d3867f499556263c64c621914/kiwisolver-1.4.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a2899935e724dd1074cb568ce7ac0dce28b2cd6ab539c8e001a8578eb106d14", size = 64952, upload-time = "2025-08-10T21:26:12.058Z" }, + { url = "https://files.pythonhosted.org/packages/70/90/6d240beb0f24b74371762873e9b7f499f1e02166a2d9c5801f4dbf8fa12e/kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f6008a4919fdbc0b0097089f67a1eb55d950ed7e90ce2cc3e640abadd2757a04", size = 1474756, upload-time = "2025-08-10T21:26:13.096Z" }, + { url = "https://files.pythonhosted.org/packages/12/42/f36816eaf465220f683fb711efdd1bbf7a7005a2473d0e4ed421389bd26c/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67bb8b474b4181770f926f7b7d2f8c0248cbcb78b660fdd41a47054b28d2a752", size = 1276404, upload-time = "2025-08-10T21:26:14.457Z" }, + { url = "https://files.pythonhosted.org/packages/2e/64/bc2de94800adc830c476dce44e9b40fd0809cddeef1fde9fcf0f73da301f/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2327a4a30d3ee07d2fbe2e7933e8a37c591663b96ce42a00bc67461a87d7df77", size = 1294410, upload-time = "2025-08-10T21:26:15.73Z" }, + { url = "https://files.pythonhosted.org/packages/5f/42/2dc82330a70aa8e55b6d395b11018045e58d0bb00834502bf11509f79091/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a08b491ec91b1d5053ac177afe5290adacf1f0f6307d771ccac5de30592d198", size = 1343631, upload-time = "2025-08-10T21:26:17.045Z" }, + { url = "https://files.pythonhosted.org/packages/22/fd/f4c67a6ed1aab149ec5a8a401c323cee7a1cbe364381bb6c9c0d564e0e20/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8fc5c867c22b828001b6a38d2eaeb88160bf5783c6cb4a5e440efc981ce286d", size = 2224963, upload-time = "2025-08-10T21:26:18.737Z" }, + { url = "https://files.pythonhosted.org/packages/45/aa/76720bd4cb3713314677d9ec94dcc21ced3f1baf4830adde5bb9b2430a5f/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3b3115b2581ea35bb6d1f24a4c90af37e5d9b49dcff267eeed14c3893c5b86ab", size = 2321295, upload-time = "2025-08-10T21:26:20.11Z" }, + { url = "https://files.pythonhosted.org/packages/80/19/d3ec0d9ab711242f56ae0dc2fc5d70e298bb4a1f9dfab44c027668c673a1/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858e4c22fb075920b96a291928cb7dea5644e94c0ee4fcd5af7e865655e4ccf2", size = 2487987, upload-time = "2025-08-10T21:26:21.49Z" }, + { url = "https://files.pythonhosted.org/packages/39/e9/61e4813b2c97e86b6fdbd4dd824bf72d28bcd8d4849b8084a357bc0dd64d/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed0fecd28cc62c54b262e3736f8bb2512d8dcfdc2bcf08be5f47f96bf405b145", size = 2291817, upload-time = "2025-08-10T21:26:22.812Z" }, + { url = "https://files.pythonhosted.org/packages/a0/41/85d82b0291db7504da3c2defe35c9a8a5c9803a730f297bd823d11d5fb77/kiwisolver-1.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:f68208a520c3d86ea51acf688a3e3002615a7f0238002cccc17affecc86a8a54", size = 73895, upload-time = "2025-08-10T21:26:24.37Z" }, + { url = "https://files.pythonhosted.org/packages/e2/92/5f3068cf15ee5cb624a0c7596e67e2a0bb2adee33f71c379054a491d07da/kiwisolver-1.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:2c1a4f57df73965f3f14df20b80ee29e6a7930a57d2d9e8491a25f676e197c60", size = 64992, upload-time = "2025-08-10T21:26:25.732Z" }, + { url = "https://files.pythonhosted.org/packages/31/c1/c2686cda909742ab66c7388e9a1a8521a59eb89f8bcfbee28fc980d07e24/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8", size = 123681, upload-time = "2025-08-10T21:26:26.725Z" }, + { url = "https://files.pythonhosted.org/packages/ca/f0/f44f50c9f5b1a1860261092e3bc91ecdc9acda848a8b8c6abfda4a24dd5c/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2", size = 66464, upload-time = "2025-08-10T21:26:27.733Z" }, + { url = "https://files.pythonhosted.org/packages/2d/7a/9d90a151f558e29c3936b8a47ac770235f436f2120aca41a6d5f3d62ae8d/kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f", size = 64961, upload-time = "2025-08-10T21:26:28.729Z" }, + { url = "https://files.pythonhosted.org/packages/e9/e9/f218a2cb3a9ffbe324ca29a9e399fa2d2866d7f348ec3a88df87fc248fc5/kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098", size = 1474607, upload-time = "2025-08-10T21:26:29.798Z" }, + { url = "https://files.pythonhosted.org/packages/d9/28/aac26d4c882f14de59041636292bc838db8961373825df23b8eeb807e198/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed", size = 1276546, upload-time = "2025-08-10T21:26:31.401Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ad/8bfc1c93d4cc565e5069162f610ba2f48ff39b7de4b5b8d93f69f30c4bed/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525", size = 1294482, upload-time = "2025-08-10T21:26:32.721Z" }, + { url = "https://files.pythonhosted.org/packages/da/f1/6aca55ff798901d8ce403206d00e033191f63d82dd708a186e0ed2067e9c/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78", size = 1343720, upload-time = "2025-08-10T21:26:34.032Z" }, + { url = "https://files.pythonhosted.org/packages/d1/91/eed031876c595c81d90d0f6fc681ece250e14bf6998c3d7c419466b523b7/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b", size = 2224907, upload-time = "2025-08-10T21:26:35.824Z" }, + { url = "https://files.pythonhosted.org/packages/e9/ec/4d1925f2e49617b9cca9c34bfa11adefad49d00db038e692a559454dfb2e/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799", size = 2321334, upload-time = "2025-08-10T21:26:37.534Z" }, + { url = "https://files.pythonhosted.org/packages/43/cb/450cd4499356f68802750c6ddc18647b8ea01ffa28f50d20598e0befe6e9/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3", size = 2488313, upload-time = "2025-08-10T21:26:39.191Z" }, + { url = "https://files.pythonhosted.org/packages/71/67/fc76242bd99f885651128a5d4fa6083e5524694b7c88b489b1b55fdc491d/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c", size = 2291970, upload-time = "2025-08-10T21:26:40.828Z" }, + { url = "https://files.pythonhosted.org/packages/75/bd/f1a5d894000941739f2ae1b65a32892349423ad49c2e6d0771d0bad3fae4/kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d", size = 73894, upload-time = "2025-08-10T21:26:42.33Z" }, + { url = "https://files.pythonhosted.org/packages/95/38/dce480814d25b99a391abbddadc78f7c117c6da34be68ca8b02d5848b424/kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2", size = 64995, upload-time = "2025-08-10T21:26:43.889Z" }, + { url = "https://files.pythonhosted.org/packages/e2/37/7d218ce5d92dadc5ebdd9070d903e0c7cf7edfe03f179433ac4d13ce659c/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1", size = 126510, upload-time = "2025-08-10T21:26:44.915Z" }, + { url = "https://files.pythonhosted.org/packages/23/b0/e85a2b48233daef4b648fb657ebbb6f8367696a2d9548a00b4ee0eb67803/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1", size = 67903, upload-time = "2025-08-10T21:26:45.934Z" }, + { url = "https://files.pythonhosted.org/packages/44/98/f2425bc0113ad7de24da6bb4dae1343476e95e1d738be7c04d31a5d037fd/kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11", size = 66402, upload-time = "2025-08-10T21:26:47.101Z" }, + { url = "https://files.pythonhosted.org/packages/98/d8/594657886df9f34c4177cc353cc28ca7e6e5eb562d37ccc233bff43bbe2a/kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c", size = 1582135, upload-time = "2025-08-10T21:26:48.665Z" }, + { url = "https://files.pythonhosted.org/packages/5c/c6/38a115b7170f8b306fc929e166340c24958347308ea3012c2b44e7e295db/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197", size = 1389409, upload-time = "2025-08-10T21:26:50.335Z" }, + { url = "https://files.pythonhosted.org/packages/bf/3b/e04883dace81f24a568bcee6eb3001da4ba05114afa622ec9b6fafdc1f5e/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c", size = 1401763, upload-time = "2025-08-10T21:26:51.867Z" }, + { url = "https://files.pythonhosted.org/packages/9f/80/20ace48e33408947af49d7d15c341eaee69e4e0304aab4b7660e234d6288/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185", size = 1453643, upload-time = "2025-08-10T21:26:53.592Z" }, + { url = "https://files.pythonhosted.org/packages/64/31/6ce4380a4cd1f515bdda976a1e90e547ccd47b67a1546d63884463c92ca9/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748", size = 2330818, upload-time = "2025-08-10T21:26:55.051Z" }, + { url = "https://files.pythonhosted.org/packages/fa/e9/3f3fcba3bcc7432c795b82646306e822f3fd74df0ee81f0fa067a1f95668/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64", size = 2419963, upload-time = "2025-08-10T21:26:56.421Z" }, + { url = "https://files.pythonhosted.org/packages/99/43/7320c50e4133575c66e9f7dadead35ab22d7c012a3b09bb35647792b2a6d/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff", size = 2594639, upload-time = "2025-08-10T21:26:57.882Z" }, + { url = "https://files.pythonhosted.org/packages/65/d6/17ae4a270d4a987ef8a385b906d2bdfc9fce502d6dc0d3aea865b47f548c/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07", size = 2391741, upload-time = "2025-08-10T21:26:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/2a/8f/8f6f491d595a9e5912971f3f863d81baddccc8a4d0c3749d6a0dd9ffc9df/kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c", size = 68646, upload-time = "2025-08-10T21:27:00.52Z" }, + { url = "https://files.pythonhosted.org/packages/6b/32/6cc0fbc9c54d06c2969faa9c1d29f5751a2e51809dd55c69055e62d9b426/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9928fe1eb816d11ae170885a74d074f57af3a0d65777ca47e9aeb854a1fba386", size = 123806, upload-time = "2025-08-10T21:27:01.537Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/2bfb1d4a4823d92e8cbb420fe024b8d2167f72079b3bb941207c42570bdf/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d0005b053977e7b43388ddec89fa567f43d4f6d5c2c0affe57de5ebf290dc552", size = 66605, upload-time = "2025-08-10T21:27:03.335Z" }, + { url = "https://files.pythonhosted.org/packages/f7/69/00aafdb4e4509c2ca6064646cba9cd4b37933898f426756adb2cb92ebbed/kiwisolver-1.4.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2635d352d67458b66fd0667c14cb1d4145e9560d503219034a18a87e971ce4f3", size = 64925, upload-time = "2025-08-10T21:27:04.339Z" }, + { url = "https://files.pythonhosted.org/packages/43/dc/51acc6791aa14e5cb6d8a2e28cefb0dc2886d8862795449d021334c0df20/kiwisolver-1.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:767c23ad1c58c9e827b649a9ab7809fd5fd9db266a9cf02b0e926ddc2c680d58", size = 1472414, upload-time = "2025-08-10T21:27:05.437Z" }, + { url = "https://files.pythonhosted.org/packages/3d/bb/93fa64a81db304ac8a246f834d5094fae4b13baf53c839d6bb6e81177129/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72d0eb9fba308b8311685c2268cf7d0a0639a6cd027d8128659f72bdd8a024b4", size = 1281272, upload-time = "2025-08-10T21:27:07.063Z" }, + { url = "https://files.pythonhosted.org/packages/70/e6/6df102916960fb8d05069d4bd92d6d9a8202d5a3e2444494e7cd50f65b7a/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f68e4f3eeca8fb22cc3d731f9715a13b652795ef657a13df1ad0c7dc0e9731df", size = 1298578, upload-time = "2025-08-10T21:27:08.452Z" }, + { url = "https://files.pythonhosted.org/packages/7c/47/e142aaa612f5343736b087864dbaebc53ea8831453fb47e7521fa8658f30/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d84cd4061ae292d8ac367b2c3fa3aad11cb8625a95d135fe93f286f914f3f5a6", size = 1345607, upload-time = "2025-08-10T21:27:10.125Z" }, + { url = "https://files.pythonhosted.org/packages/54/89/d641a746194a0f4d1a3670fb900d0dbaa786fb98341056814bc3f058fa52/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a60ea74330b91bd22a29638940d115df9dc00af5035a9a2a6ad9399ffb4ceca5", size = 2230150, upload-time = "2025-08-10T21:27:11.484Z" }, + { url = "https://files.pythonhosted.org/packages/aa/6b/5ee1207198febdf16ac11f78c5ae40861b809cbe0e6d2a8d5b0b3044b199/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ce6a3a4e106cf35c2d9c4fa17c05ce0b180db622736845d4315519397a77beaf", size = 2325979, upload-time = "2025-08-10T21:27:12.917Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ff/b269eefd90f4ae14dcc74973d5a0f6d28d3b9bb1afd8c0340513afe6b39a/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:77937e5e2a38a7b48eef0585114fe7930346993a88060d0bf886086d2aa49ef5", size = 2491456, upload-time = "2025-08-10T21:27:14.353Z" }, + { url = "https://files.pythonhosted.org/packages/fc/d4/10303190bd4d30de547534601e259a4fbf014eed94aae3e5521129215086/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:24c175051354f4a28c5d6a31c93906dc653e2bf234e8a4bbfb964892078898ce", size = 2294621, upload-time = "2025-08-10T21:27:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/28/e0/a9a90416fce5c0be25742729c2ea52105d62eda6c4be4d803c2a7be1fa50/kiwisolver-1.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:0763515d4df10edf6d06a3c19734e2566368980d21ebec439f33f9eb936c07b7", size = 75417, upload-time = "2025-08-10T21:27:17.436Z" }, + { url = "https://files.pythonhosted.org/packages/1f/10/6949958215b7a9a264299a7db195564e87900f709db9245e4ebdd3c70779/kiwisolver-1.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:0e4e2bf29574a6a7b7f6cb5fa69293b9f96c928949ac4a53ba3f525dffb87f9c", size = 66582, upload-time = "2025-08-10T21:27:18.436Z" }, + { url = "https://files.pythonhosted.org/packages/ec/79/60e53067903d3bc5469b369fe0dfc6b3482e2133e85dae9daa9527535991/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d976bbb382b202f71c67f77b0ac11244021cfa3f7dfd9e562eefcea2df711548", size = 126514, upload-time = "2025-08-10T21:27:19.465Z" }, + { url = "https://files.pythonhosted.org/packages/25/d1/4843d3e8d46b072c12a38c97c57fab4608d36e13fe47d47ee96b4d61ba6f/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2489e4e5d7ef9a1c300a5e0196e43d9c739f066ef23270607d45aba368b91f2d", size = 67905, upload-time = "2025-08-10T21:27:20.51Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ae/29ffcbd239aea8b93108de1278271ae764dfc0d803a5693914975f200596/kiwisolver-1.4.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e2ea9f7ab7fbf18fffb1b5434ce7c69a07582f7acc7717720f1d69f3e806f90c", size = 66399, upload-time = "2025-08-10T21:27:21.496Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ae/d7ba902aa604152c2ceba5d352d7b62106bedbccc8e95c3934d94472bfa3/kiwisolver-1.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b34e51affded8faee0dfdb705416153819d8ea9250bbbf7ea1b249bdeb5f1122", size = 1582197, upload-time = "2025-08-10T21:27:22.604Z" }, + { url = "https://files.pythonhosted.org/packages/f2/41/27c70d427eddb8bc7e4f16420a20fefc6f480312122a59a959fdfe0445ad/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8aacd3d4b33b772542b2e01beb50187536967b514b00003bdda7589722d2a64", size = 1390125, upload-time = "2025-08-10T21:27:24.036Z" }, + { url = "https://files.pythonhosted.org/packages/41/42/b3799a12bafc76d962ad69083f8b43b12bf4fe78b097b12e105d75c9b8f1/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7cf974dd4e35fa315563ac99d6287a1024e4dc2077b8a7d7cd3d2fb65d283134", size = 1402612, upload-time = "2025-08-10T21:27:25.773Z" }, + { url = "https://files.pythonhosted.org/packages/d2/b5/a210ea073ea1cfaca1bb5c55a62307d8252f531beb364e18aa1e0888b5a0/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85bd218b5ecfbee8c8a82e121802dcb519a86044c9c3b2e4aef02fa05c6da370", size = 1453990, upload-time = "2025-08-10T21:27:27.089Z" }, + { url = "https://files.pythonhosted.org/packages/5f/ce/a829eb8c033e977d7ea03ed32fb3c1781b4fa0433fbadfff29e39c676f32/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0856e241c2d3df4efef7c04a1e46b1936b6120c9bcf36dd216e3acd84bc4fb21", size = 2331601, upload-time = "2025-08-10T21:27:29.343Z" }, + { url = "https://files.pythonhosted.org/packages/e0/4b/b5e97eb142eb9cd0072dacfcdcd31b1c66dc7352b0f7c7255d339c0edf00/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9af39d6551f97d31a4deebeac6f45b156f9755ddc59c07b402c148f5dbb6482a", size = 2422041, upload-time = "2025-08-10T21:27:30.754Z" }, + { url = "https://files.pythonhosted.org/packages/40/be/8eb4cd53e1b85ba4edc3a9321666f12b83113a178845593307a3e7891f44/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:bb4ae2b57fc1d8cbd1cf7b1d9913803681ffa903e7488012be5b76dedf49297f", size = 2594897, upload-time = "2025-08-10T21:27:32.803Z" }, + { url = "https://files.pythonhosted.org/packages/99/dd/841e9a66c4715477ea0abc78da039832fbb09dac5c35c58dc4c41a407b8a/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:aedff62918805fb62d43a4aa2ecd4482c380dc76cd31bd7c8878588a61bd0369", size = 2391835, upload-time = "2025-08-10T21:27:34.23Z" }, + { url = "https://files.pythonhosted.org/packages/0c/28/4b2e5c47a0da96896fdfdb006340ade064afa1e63675d01ea5ac222b6d52/kiwisolver-1.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:1fa333e8b2ce4d9660f2cda9c0e1b6bafcfb2457a9d259faa82289e73ec24891", size = 79988, upload-time = "2025-08-10T21:27:35.587Z" }, + { url = "https://files.pythonhosted.org/packages/80/be/3578e8afd18c88cdf9cb4cffde75a96d2be38c5a903f1ed0ceec061bd09e/kiwisolver-1.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:4a48a2ce79d65d363597ef7b567ce3d14d68783d2b2263d98db3d9477805ba32", size = 70260, upload-time = "2025-08-10T21:27:36.606Z" }, +] + +[[package]] +name = "mako" +version = "1.3.10" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/38/bd5b78a920a64d708fe6bc8e0a2c075e1389d53bef8413725c63ba041535/mako-1.3.10.tar.gz", hash = "sha256:99579a6f39583fa7e5630a28c3c1f440e4e97a414b80372649c0ce338da2ea28", size = 392474, upload-time = "2025-04-10T12:44:31.16Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/fb/99f81ac72ae23375f22b7afdb7642aba97c00a713c217124420147681a2f/mako-1.3.10-py3-none-any.whl", hash = "sha256:baef24a52fc4fc514a0887ac600f9f1cff3d82c61d4d700a1fa84d597b88db59", size = 78509, upload-time = "2025-04-10T12:50:53.297Z" }, +] + +[[package]] +name = "mando" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/35/24/cd70d5ae6d35962be752feccb7dca80b5e0c2d450e995b16abd6275f3296/mando-0.7.1.tar.gz", hash = "sha256:18baa999b4b613faefb00eac4efadcf14f510b59b924b66e08289aa1de8c3500", size = 37868, upload-time = "2022-02-24T08:12:27.316Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/f0/834e479e47e499b6478e807fb57b31cc2db696c4db30557bb6f5aea4a90b/mando-0.7.1-py2.py3-none-any.whl", hash = "sha256:26ef1d70928b6057ee3ca12583d73c63e05c49de8972d620c278a7b206581a8a", size = 28149, upload-time = "2022-02-24T08:12:25.24Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/97/5d42485e71dfc078108a86d6de8fa46db44a1a9295e89c5d6d4a06e23a62/markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0", size = 20537, upload-time = "2024-10-18T15:21:54.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/09/d1f21434c97fc42f09d290cbb6350d44eb12f09cc62c9476effdb33a18aa/MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf", size = 14274, upload-time = "2024-10-18T15:21:13.777Z" }, + { url = "https://files.pythonhosted.org/packages/6b/b0/18f76bba336fa5aecf79d45dcd6c806c280ec44538b3c13671d49099fdd0/MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225", size = 12348, upload-time = "2024-10-18T15:21:14.822Z" }, + { url = "https://files.pythonhosted.org/packages/e0/25/dd5c0f6ac1311e9b40f4af06c78efde0f3b5cbf02502f8ef9501294c425b/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028", size = 24149, upload-time = "2024-10-18T15:21:15.642Z" }, + { url = "https://files.pythonhosted.org/packages/f3/f0/89e7aadfb3749d0f52234a0c8c7867877876e0a20b60e2188e9850794c17/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8", size = 23118, upload-time = "2024-10-18T15:21:17.133Z" }, + { url = "https://files.pythonhosted.org/packages/d5/da/f2eeb64c723f5e3777bc081da884b414671982008c47dcc1873d81f625b6/MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c", size = 22993, upload-time = "2024-10-18T15:21:18.064Z" }, + { url = "https://files.pythonhosted.org/packages/da/0e/1f32af846df486dce7c227fe0f2398dc7e2e51d4a370508281f3c1c5cddc/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557", size = 24178, upload-time = "2024-10-18T15:21:18.859Z" }, + { url = "https://files.pythonhosted.org/packages/c4/f6/bb3ca0532de8086cbff5f06d137064c8410d10779c4c127e0e47d17c0b71/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22", size = 23319, upload-time = "2024-10-18T15:21:19.671Z" }, + { url = "https://files.pythonhosted.org/packages/a2/82/8be4c96ffee03c5b4a034e60a31294daf481e12c7c43ab8e34a1453ee48b/MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48", size = 23352, upload-time = "2024-10-18T15:21:20.971Z" }, + { url = "https://files.pythonhosted.org/packages/51/ae/97827349d3fcffee7e184bdf7f41cd6b88d9919c80f0263ba7acd1bbcb18/MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30", size = 15097, upload-time = "2024-10-18T15:21:22.646Z" }, + { url = "https://files.pythonhosted.org/packages/c1/80/a61f99dc3a936413c3ee4e1eecac96c0da5ed07ad56fd975f1a9da5bc630/MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87", size = 15601, upload-time = "2024-10-18T15:21:23.499Z" }, + { url = "https://files.pythonhosted.org/packages/83/0e/67eb10a7ecc77a0c2bbe2b0235765b98d164d81600746914bebada795e97/MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd", size = 14274, upload-time = "2024-10-18T15:21:24.577Z" }, + { url = "https://files.pythonhosted.org/packages/2b/6d/9409f3684d3335375d04e5f05744dfe7e9f120062c9857df4ab490a1031a/MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430", size = 12352, upload-time = "2024-10-18T15:21:25.382Z" }, + { url = "https://files.pythonhosted.org/packages/d2/f5/6eadfcd3885ea85fe2a7c128315cc1bb7241e1987443d78c8fe712d03091/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094", size = 24122, upload-time = "2024-10-18T15:21:26.199Z" }, + { url = "https://files.pythonhosted.org/packages/0c/91/96cf928db8236f1bfab6ce15ad070dfdd02ed88261c2afafd4b43575e9e9/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396", size = 23085, upload-time = "2024-10-18T15:21:27.029Z" }, + { url = "https://files.pythonhosted.org/packages/c2/cf/c9d56af24d56ea04daae7ac0940232d31d5a8354f2b457c6d856b2057d69/MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79", size = 22978, upload-time = "2024-10-18T15:21:27.846Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9f/8619835cd6a711d6272d62abb78c033bda638fdc54c4e7f4272cf1c0962b/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a", size = 24208, upload-time = "2024-10-18T15:21:28.744Z" }, + { url = "https://files.pythonhosted.org/packages/f9/bf/176950a1792b2cd2102b8ffeb5133e1ed984547b75db47c25a67d3359f77/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca", size = 23357, upload-time = "2024-10-18T15:21:29.545Z" }, + { url = "https://files.pythonhosted.org/packages/ce/4f/9a02c1d335caabe5c4efb90e1b6e8ee944aa245c1aaaab8e8a618987d816/MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c", size = 23344, upload-time = "2024-10-18T15:21:30.366Z" }, + { url = "https://files.pythonhosted.org/packages/ee/55/c271b57db36f748f0e04a759ace9f8f759ccf22b4960c270c78a394f58be/MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1", size = 15101, upload-time = "2024-10-18T15:21:31.207Z" }, + { url = "https://files.pythonhosted.org/packages/29/88/07df22d2dd4df40aba9f3e402e6dc1b8ee86297dddbad4872bd5e7b0094f/MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f", size = 15603, upload-time = "2024-10-18T15:21:32.032Z" }, + { url = "https://files.pythonhosted.org/packages/62/6a/8b89d24db2d32d433dffcd6a8779159da109842434f1dd2f6e71f32f738c/MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c", size = 14510, upload-time = "2024-10-18T15:21:33.625Z" }, + { url = "https://files.pythonhosted.org/packages/7a/06/a10f955f70a2e5a9bf78d11a161029d278eeacbd35ef806c3fd17b13060d/MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb", size = 12486, upload-time = "2024-10-18T15:21:34.611Z" }, + { url = "https://files.pythonhosted.org/packages/34/cf/65d4a571869a1a9078198ca28f39fba5fbb910f952f9dbc5220afff9f5e6/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c", size = 25480, upload-time = "2024-10-18T15:21:35.398Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e3/90e9651924c430b885468b56b3d597cabf6d72be4b24a0acd1fa0e12af67/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d", size = 23914, upload-time = "2024-10-18T15:21:36.231Z" }, + { url = "https://files.pythonhosted.org/packages/66/8c/6c7cf61f95d63bb866db39085150df1f2a5bd3335298f14a66b48e92659c/MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe", size = 23796, upload-time = "2024-10-18T15:21:37.073Z" }, + { url = "https://files.pythonhosted.org/packages/bb/35/cbe9238ec3f47ac9a7c8b3df7a808e7cb50fe149dc7039f5f454b3fba218/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5", size = 25473, upload-time = "2024-10-18T15:21:37.932Z" }, + { url = "https://files.pythonhosted.org/packages/e6/32/7621a4382488aa283cc05e8984a9c219abad3bca087be9ec77e89939ded9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a", size = 24114, upload-time = "2024-10-18T15:21:39.799Z" }, + { url = "https://files.pythonhosted.org/packages/0d/80/0985960e4b89922cb5a0bac0ed39c5b96cbc1a536a99f30e8c220a996ed9/MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9", size = 24098, upload-time = "2024-10-18T15:21:40.813Z" }, + { url = "https://files.pythonhosted.org/packages/82/78/fedb03c7d5380df2427038ec8d973587e90561b2d90cd472ce9254cf348b/MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6", size = 15208, upload-time = "2024-10-18T15:21:41.814Z" }, + { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739, upload-time = "2024-10-18T15:21:42.784Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a0/59/c3e6453a9676ffba145309a73c462bb407f4400de7de3f2b41af70720a3c/matplotlib-3.10.6.tar.gz", hash = "sha256:ec01b645840dd1996df21ee37f208cd8ba57644779fa20464010638013d3203c", size = 34804264, upload-time = "2025-08-30T00:14:25.137Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ea/1a/7042f7430055d567cc3257ac409fcf608599ab27459457f13772c2d9778b/matplotlib-3.10.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:31ca662df6a80bd426f871105fdd69db7543e28e73a9f2afe80de7e531eb2347", size = 8272404, upload-time = "2025-08-30T00:12:59.112Z" }, + { url = "https://files.pythonhosted.org/packages/a9/5d/1d5f33f5b43f4f9e69e6a5fe1fb9090936ae7bc8e2ff6158e7a76542633b/matplotlib-3.10.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1678bb61d897bb4ac4757b5ecfb02bfb3fddf7f808000fb81e09c510712fda75", size = 8128262, upload-time = "2025-08-30T00:13:01.141Z" }, + { url = "https://files.pythonhosted.org/packages/67/c3/135fdbbbf84e0979712df58e5e22b4f257b3f5e52a3c4aacf1b8abec0d09/matplotlib-3.10.6-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:56cd2d20842f58c03d2d6e6c1f1cf5548ad6f66b91e1e48f814e4fb5abd1cb95", size = 8697008, upload-time = "2025-08-30T00:13:03.24Z" }, + { url = "https://files.pythonhosted.org/packages/9c/be/c443ea428fb2488a3ea7608714b1bd85a82738c45da21b447dc49e2f8e5d/matplotlib-3.10.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:662df55604a2f9a45435566d6e2660e41efe83cd94f4288dfbf1e6d1eae4b0bb", size = 9530166, upload-time = "2025-08-30T00:13:05.951Z" }, + { url = "https://files.pythonhosted.org/packages/a9/35/48441422b044d74034aea2a3e0d1a49023f12150ebc58f16600132b9bbaf/matplotlib-3.10.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:08f141d55148cd1fc870c3387d70ca4df16dee10e909b3b038782bd4bda6ea07", size = 9593105, upload-time = "2025-08-30T00:13:08.356Z" }, + { url = "https://files.pythonhosted.org/packages/45/c3/994ef20eb4154ab84cc08d033834555319e4af970165e6c8894050af0b3c/matplotlib-3.10.6-cp312-cp312-win_amd64.whl", hash = "sha256:590f5925c2d650b5c9d813c5b3b5fc53f2929c3f8ef463e4ecfa7e052044fb2b", size = 8122784, upload-time = "2025-08-30T00:13:10.367Z" }, + { url = "https://files.pythonhosted.org/packages/57/b8/5c85d9ae0e40f04e71bedb053aada5d6bab1f9b5399a0937afb5d6b02d98/matplotlib-3.10.6-cp312-cp312-win_arm64.whl", hash = "sha256:f44c8d264a71609c79a78d50349e724f5d5fc3684ead7c2a473665ee63d868aa", size = 7992823, upload-time = "2025-08-30T00:13:12.24Z" }, + { url = "https://files.pythonhosted.org/packages/a0/db/18380e788bb837e724358287b08e223b32bc8dccb3b0c12fa8ca20bc7f3b/matplotlib-3.10.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:819e409653c1106c8deaf62e6de6b8611449c2cd9939acb0d7d4e57a3d95cc7a", size = 8273231, upload-time = "2025-08-30T00:13:13.881Z" }, + { url = "https://files.pythonhosted.org/packages/d3/0f/38dd49445b297e0d4f12a322c30779df0d43cb5873c7847df8a82e82ec67/matplotlib-3.10.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:59c8ac8382fefb9cb71308dde16a7c487432f5255d8f1fd32473523abecfecdf", size = 8128730, upload-time = "2025-08-30T00:13:15.556Z" }, + { url = "https://files.pythonhosted.org/packages/e5/b8/9eea6630198cb303d131d95d285a024b3b8645b1763a2916fddb44ca8760/matplotlib-3.10.6-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:84e82d9e0fd70c70bc55739defbd8055c54300750cbacf4740c9673a24d6933a", size = 8698539, upload-time = "2025-08-30T00:13:17.297Z" }, + { url = "https://files.pythonhosted.org/packages/71/34/44c7b1f075e1ea398f88aeabcc2907c01b9cc99e2afd560c1d49845a1227/matplotlib-3.10.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25f7a3eb42d6c1c56e89eacd495661fc815ffc08d9da750bca766771c0fd9110", size = 9529702, upload-time = "2025-08-30T00:13:19.248Z" }, + { url = "https://files.pythonhosted.org/packages/b5/7f/e5c2dc9950c7facaf8b461858d1b92c09dd0cf174fe14e21953b3dda06f7/matplotlib-3.10.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f9c862d91ec0b7842920a4cfdaaec29662195301914ea54c33e01f1a28d014b2", size = 9593742, upload-time = "2025-08-30T00:13:21.181Z" }, + { url = "https://files.pythonhosted.org/packages/ff/1d/70c28528794f6410ee2856cd729fa1f1756498b8d3126443b0a94e1a8695/matplotlib-3.10.6-cp313-cp313-win_amd64.whl", hash = "sha256:1b53bd6337eba483e2e7d29c5ab10eee644bc3a2491ec67cc55f7b44583ffb18", size = 8122753, upload-time = "2025-08-30T00:13:23.44Z" }, + { url = "https://files.pythonhosted.org/packages/e8/74/0e1670501fc7d02d981564caf7c4df42974464625935424ca9654040077c/matplotlib-3.10.6-cp313-cp313-win_arm64.whl", hash = "sha256:cbd5eb50b7058b2892ce45c2f4e92557f395c9991f5c886d1bb74a1582e70fd6", size = 7992973, upload-time = "2025-08-30T00:13:26.632Z" }, + { url = "https://files.pythonhosted.org/packages/b1/4e/60780e631d73b6b02bd7239f89c451a72970e5e7ec34f621eda55cd9a445/matplotlib-3.10.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:acc86dd6e0e695c095001a7fccff158c49e45e0758fdf5dcdbb0103318b59c9f", size = 8316869, upload-time = "2025-08-30T00:13:28.262Z" }, + { url = "https://files.pythonhosted.org/packages/f8/15/baa662374a579413210fc2115d40c503b7360a08e9cc254aa0d97d34b0c1/matplotlib-3.10.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e228cd2ffb8f88b7d0b29e37f68ca9aaf83e33821f24a5ccc4f082dd8396bc27", size = 8178240, upload-time = "2025-08-30T00:13:30.007Z" }, + { url = "https://files.pythonhosted.org/packages/c6/3f/3c38e78d2aafdb8829fcd0857d25aaf9e7dd2dfcf7ec742765b585774931/matplotlib-3.10.6-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:658bc91894adeab669cf4bb4a186d049948262987e80f0857216387d7435d833", size = 8711719, upload-time = "2025-08-30T00:13:31.72Z" }, + { url = "https://files.pythonhosted.org/packages/96/4b/2ec2bbf8cefaa53207cc56118d1fa8a0f9b80642713ea9390235d331ede4/matplotlib-3.10.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8913b7474f6dd83ac444c9459c91f7f0f2859e839f41d642691b104e0af056aa", size = 9541422, upload-time = "2025-08-30T00:13:33.611Z" }, + { url = "https://files.pythonhosted.org/packages/83/7d/40255e89b3ef11c7871020563b2dd85f6cb1b4eff17c0f62b6eb14c8fa80/matplotlib-3.10.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:091cea22e059b89f6d7d1a18e2c33a7376c26eee60e401d92a4d6726c4e12706", size = 9594068, upload-time = "2025-08-30T00:13:35.833Z" }, + { url = "https://files.pythonhosted.org/packages/f0/a9/0213748d69dc842537a113493e1c27daf9f96bd7cc316f933dc8ec4de985/matplotlib-3.10.6-cp313-cp313t-win_amd64.whl", hash = "sha256:491e25e02a23d7207629d942c666924a6b61e007a48177fdd231a0097b7f507e", size = 8200100, upload-time = "2025-08-30T00:13:37.668Z" }, + { url = "https://files.pythonhosted.org/packages/be/15/79f9988066ce40b8a6f1759a934ea0cde8dc4adc2262255ee1bc98de6ad0/matplotlib-3.10.6-cp313-cp313t-win_arm64.whl", hash = "sha256:3d80d60d4e54cda462e2cd9a086d85cd9f20943ead92f575ce86885a43a565d5", size = 8042142, upload-time = "2025-08-30T00:13:39.426Z" }, + { url = "https://files.pythonhosted.org/packages/7c/58/e7b6d292beae6fb4283ca6fb7fa47d7c944a68062d6238c07b497dd35493/matplotlib-3.10.6-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:70aaf890ce1d0efd482df969b28a5b30ea0b891224bb315810a3940f67182899", size = 8273802, upload-time = "2025-08-30T00:13:41.006Z" }, + { url = "https://files.pythonhosted.org/packages/9f/f6/7882d05aba16a8cdd594fb9a03a9d3cca751dbb6816adf7b102945522ee9/matplotlib-3.10.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1565aae810ab79cb72e402b22facfa6501365e73ebab70a0fdfb98488d2c3c0c", size = 8131365, upload-time = "2025-08-30T00:13:42.664Z" }, + { url = "https://files.pythonhosted.org/packages/94/bf/ff32f6ed76e78514e98775a53715eca4804b12bdcf35902cdd1cf759d324/matplotlib-3.10.6-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3b23315a01981689aa4e1a179dbf6ef9fbd17143c3eea77548c2ecfb0499438", size = 9533961, upload-time = "2025-08-30T00:13:44.372Z" }, + { url = "https://files.pythonhosted.org/packages/fe/c3/6bf88c2fc2da7708a2ff8d2eeb5d68943130f50e636d5d3dcf9d4252e971/matplotlib-3.10.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30fdd37edf41a4e6785f9b37969de57aea770696cb637d9946eb37470c94a453", size = 9804262, upload-time = "2025-08-30T00:13:46.614Z" }, + { url = "https://files.pythonhosted.org/packages/0f/7a/e05e6d9446d2d577b459427ad060cd2de5742d0e435db3191fea4fcc7e8b/matplotlib-3.10.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:bc31e693da1c08012c764b053e702c1855378e04102238e6a5ee6a7117c53a47", size = 9595508, upload-time = "2025-08-30T00:13:48.731Z" }, + { url = "https://files.pythonhosted.org/packages/39/fb/af09c463ced80b801629fd73b96f726c9f6124c3603aa2e480a061d6705b/matplotlib-3.10.6-cp314-cp314-win_amd64.whl", hash = "sha256:05be9bdaa8b242bc6ff96330d18c52f1fc59c6fb3a4dd411d953d67e7e1baf98", size = 8252742, upload-time = "2025-08-30T00:13:50.539Z" }, + { url = "https://files.pythonhosted.org/packages/b1/f9/b682f6db9396d9ab8f050c0a3bfbb5f14fb0f6518f08507c04cc02f8f229/matplotlib-3.10.6-cp314-cp314-win_arm64.whl", hash = "sha256:f56a0d1ab05d34c628592435781d185cd99630bdfd76822cd686fb5a0aecd43a", size = 8124237, upload-time = "2025-08-30T00:13:54.3Z" }, + { url = "https://files.pythonhosted.org/packages/b5/d2/b69b4a0923a3c05ab90527c60fdec899ee21ca23ede7f0fb818e6620d6f2/matplotlib-3.10.6-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:94f0b4cacb23763b64b5dace50d5b7bfe98710fed5f0cef5c08135a03399d98b", size = 8316956, upload-time = "2025-08-30T00:13:55.932Z" }, + { url = "https://files.pythonhosted.org/packages/28/e9/dc427b6f16457ffaeecb2fc4abf91e5adb8827861b869c7a7a6d1836fa73/matplotlib-3.10.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cc332891306b9fb39462673d8225d1b824c89783fee82840a709f96714f17a5c", size = 8178260, upload-time = "2025-08-30T00:14:00.942Z" }, + { url = "https://files.pythonhosted.org/packages/c4/89/1fbd5ad611802c34d1c7ad04607e64a1350b7fb9c567c4ec2c19e066ed35/matplotlib-3.10.6-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee1d607b3fb1590deb04b69f02ea1d53ed0b0bf75b2b1a5745f269afcbd3cdd3", size = 9541422, upload-time = "2025-08-30T00:14:02.664Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3b/65fec8716025b22c1d72d5a82ea079934c76a547696eaa55be6866bc89b1/matplotlib-3.10.6-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:376a624a218116461696b27b2bbf7a8945053e6d799f6502fc03226d077807bf", size = 9803678, upload-time = "2025-08-30T00:14:04.741Z" }, + { url = "https://files.pythonhosted.org/packages/c7/b0/40fb2b3a1ab9381bb39a952e8390357c8be3bdadcf6d5055d9c31e1b35ae/matplotlib-3.10.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:83847b47f6524c34b4f2d3ce726bb0541c48c8e7692729865c3df75bfa0f495a", size = 9594077, upload-time = "2025-08-30T00:14:07.012Z" }, + { url = "https://files.pythonhosted.org/packages/76/34/c4b71b69edf5b06e635eee1ed10bfc73cf8df058b66e63e30e6a55e231d5/matplotlib-3.10.6-cp314-cp314t-win_amd64.whl", hash = "sha256:c7e0518e0d223683532a07f4b512e2e0729b62674f1b3a1a69869f98e6b1c7e3", size = 8342822, upload-time = "2025-08-30T00:14:09.041Z" }, + { url = "https://files.pythonhosted.org/packages/e8/62/aeabeef1a842b6226a30d49dd13e8a7a1e81e9ec98212c0b5169f0a12d83/matplotlib-3.10.6-cp314-cp314t-win_arm64.whl", hash = "sha256:4dd83e029f5b4801eeb87c64efd80e732452781c16a9cf7415b7b63ec8f374d7", size = 8172588, upload-time = "2025-08-30T00:14:11.166Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159, upload-time = "2024-04-15T13:44:44.803Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899, upload-time = "2024-04-15T13:44:43.265Z" }, +] + +[[package]] +name = "mccabe" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/ff/0ffefdcac38932a54d2b5eed4e0ba8a408f215002cd178ad1df0f2806ff8/mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325", size = 9658, upload-time = "2022-01-24T01:14:51.113Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/1a/1f68f9ba0c207934b35b86a8ca3aad8395a3d6dd7921c0686e23853ff5a9/mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e", size = 7350, upload-time = "2022-01-24T01:14:49.62Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "mypy" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8e/22/ea637422dedf0bf36f3ef238eab4e455e2a0dcc3082b5cc067615347ab8e/mypy-1.17.1.tar.gz", hash = "sha256:25e01ec741ab5bb3eec8ba9cdb0f769230368a22c959c4937360efb89b7e9f01", size = 3352570, upload-time = "2025-07-31T07:54:19.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/a2/7034d0d61af8098ec47902108553122baa0f438df8a713be860f7407c9e6/mypy-1.17.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:69e83ea6553a3ba79c08c6e15dbd9bfa912ec1e493bf75489ef93beb65209aeb", size = 11086295, upload-time = "2025-07-31T07:53:28.124Z" }, + { url = "https://files.pythonhosted.org/packages/14/1f/19e7e44b594d4b12f6ba8064dbe136505cec813549ca3e5191e40b1d3cc2/mypy-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1b16708a66d38abb1e6b5702f5c2c87e133289da36f6a1d15f6a5221085c6403", size = 10112355, upload-time = "2025-07-31T07:53:21.121Z" }, + { url = "https://files.pythonhosted.org/packages/5b/69/baa33927e29e6b4c55d798a9d44db5d394072eef2bdc18c3e2048c9ed1e9/mypy-1.17.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:89e972c0035e9e05823907ad5398c5a73b9f47a002b22359b177d40bdaee7056", size = 11875285, upload-time = "2025-07-31T07:53:55.293Z" }, + { url = "https://files.pythonhosted.org/packages/90/13/f3a89c76b0a41e19490b01e7069713a30949d9a6c147289ee1521bcea245/mypy-1.17.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03b6d0ed2b188e35ee6d5c36b5580cffd6da23319991c49ab5556c023ccf1341", size = 12737895, upload-time = "2025-07-31T07:53:43.623Z" }, + { url = "https://files.pythonhosted.org/packages/23/a1/c4ee79ac484241301564072e6476c5a5be2590bc2e7bfd28220033d2ef8f/mypy-1.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c837b896b37cd103570d776bda106eabb8737aa6dd4f248451aecf53030cdbeb", size = 12931025, upload-time = "2025-07-31T07:54:17.125Z" }, + { url = "https://files.pythonhosted.org/packages/89/b8/7409477be7919a0608900e6320b155c72caab4fef46427c5cc75f85edadd/mypy-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:665afab0963a4b39dff7c1fa563cc8b11ecff7910206db4b2e64dd1ba25aed19", size = 9584664, upload-time = "2025-07-31T07:54:12.842Z" }, + { url = "https://files.pythonhosted.org/packages/5b/82/aec2fc9b9b149f372850291827537a508d6c4d3664b1750a324b91f71355/mypy-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93378d3203a5c0800c6b6d850ad2f19f7a3cdf1a3701d3416dbf128805c6a6a7", size = 11075338, upload-time = "2025-07-31T07:53:38.873Z" }, + { url = "https://files.pythonhosted.org/packages/07/ac/ee93fbde9d2242657128af8c86f5d917cd2887584cf948a8e3663d0cd737/mypy-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:15d54056f7fe7a826d897789f53dd6377ec2ea8ba6f776dc83c2902b899fee81", size = 10113066, upload-time = "2025-07-31T07:54:14.707Z" }, + { url = "https://files.pythonhosted.org/packages/5a/68/946a1e0be93f17f7caa56c45844ec691ca153ee8b62f21eddda336a2d203/mypy-1.17.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:209a58fed9987eccc20f2ca94afe7257a8f46eb5df1fb69958650973230f91e6", size = 11875473, upload-time = "2025-07-31T07:53:14.504Z" }, + { url = "https://files.pythonhosted.org/packages/9f/0f/478b4dce1cb4f43cf0f0d00fba3030b21ca04a01b74d1cd272a528cf446f/mypy-1.17.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:099b9a5da47de9e2cb5165e581f158e854d9e19d2e96b6698c0d64de911dd849", size = 12744296, upload-time = "2025-07-31T07:53:03.896Z" }, + { url = "https://files.pythonhosted.org/packages/ca/70/afa5850176379d1b303f992a828de95fc14487429a7139a4e0bdd17a8279/mypy-1.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa6ffadfbe6994d724c5a1bb6123a7d27dd68fc9c059561cd33b664a79578e14", size = 12914657, upload-time = "2025-07-31T07:54:08.576Z" }, + { url = "https://files.pythonhosted.org/packages/53/f9/4a83e1c856a3d9c8f6edaa4749a4864ee98486e9b9dbfbc93842891029c2/mypy-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:9a2b7d9180aed171f033c9f2fc6c204c1245cf60b0cb61cf2e7acc24eea78e0a", size = 9593320, upload-time = "2025-07-31T07:53:01.341Z" }, + { url = "https://files.pythonhosted.org/packages/38/56/79c2fac86da57c7d8c48622a05873eaab40b905096c33597462713f5af90/mypy-1.17.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:15a83369400454c41ed3a118e0cc58bd8123921a602f385cb6d6ea5df050c733", size = 11040037, upload-time = "2025-07-31T07:54:10.942Z" }, + { url = "https://files.pythonhosted.org/packages/4d/c3/adabe6ff53638e3cad19e3547268482408323b1e68bf082c9119000cd049/mypy-1.17.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:55b918670f692fc9fba55c3298d8a3beae295c5cded0a55dccdc5bbead814acd", size = 10131550, upload-time = "2025-07-31T07:53:41.307Z" }, + { url = "https://files.pythonhosted.org/packages/b8/c5/2e234c22c3bdeb23a7817af57a58865a39753bde52c74e2c661ee0cfc640/mypy-1.17.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:62761474061feef6f720149d7ba876122007ddc64adff5ba6f374fda35a018a0", size = 11872963, upload-time = "2025-07-31T07:53:16.878Z" }, + { url = "https://files.pythonhosted.org/packages/ab/26/c13c130f35ca8caa5f2ceab68a247775648fdcd6c9a18f158825f2bc2410/mypy-1.17.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c49562d3d908fd49ed0938e5423daed8d407774a479b595b143a3d7f87cdae6a", size = 12710189, upload-time = "2025-07-31T07:54:01.962Z" }, + { url = "https://files.pythonhosted.org/packages/82/df/c7d79d09f6de8383fe800521d066d877e54d30b4fb94281c262be2df84ef/mypy-1.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:397fba5d7616a5bc60b45c7ed204717eaddc38f826e3645402c426057ead9a91", size = 12900322, upload-time = "2025-07-31T07:53:10.551Z" }, + { url = "https://files.pythonhosted.org/packages/b8/98/3d5a48978b4f708c55ae832619addc66d677f6dc59f3ebad71bae8285ca6/mypy-1.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:9d6b20b97d373f41617bd0708fd46aa656059af57f2ef72aa8c7d6a2b73b74ed", size = 9751879, upload-time = "2025-07-31T07:52:56.683Z" }, + { url = "https://files.pythonhosted.org/packages/1d/f3/8fcd2af0f5b806f6cf463efaffd3c9548a28f84220493ecd38d127b6b66d/mypy-1.17.1-py3-none-any.whl", hash = "sha256:a9f52c0351c21fe24c21d8c0eb1f62967b262d6729393397b6f443c3b773c3b9", size = 2283411, upload-time = "2025-07-31T07:53:24.664Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, +] + +[[package]] +name = "numpy" +version = "2.3.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/19/95b3d357407220ed24c139018d2518fab0a61a948e68286a25f1a4d049ff/numpy-2.3.3.tar.gz", hash = "sha256:ddc7c39727ba62b80dfdbedf400d1c10ddfa8eefbd7ec8dcb118be8b56d31029", size = 20576648, upload-time = "2025-09-09T16:54:12.543Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/5d/bb7fc075b762c96329147799e1bcc9176ab07ca6375ea976c475482ad5b3/numpy-2.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cfdd09f9c84a1a934cde1eec2267f0a43a7cd44b2cca4ff95b7c0d14d144b0bf", size = 20957014, upload-time = "2025-09-09T15:56:29.966Z" }, + { url = "https://files.pythonhosted.org/packages/6b/0e/c6211bb92af26517acd52125a237a92afe9c3124c6a68d3b9f81b62a0568/numpy-2.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cb32e3cf0f762aee47ad1ddc6672988f7f27045b0783c887190545baba73aa25", size = 14185220, upload-time = "2025-09-09T15:56:32.175Z" }, + { url = "https://files.pythonhosted.org/packages/22/f2/07bb754eb2ede9073f4054f7c0286b0d9d2e23982e090a80d478b26d35ca/numpy-2.3.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:396b254daeb0a57b1fe0ecb5e3cff6fa79a380fa97c8f7781a6d08cd429418fe", size = 5113918, upload-time = "2025-09-09T15:56:34.175Z" }, + { url = "https://files.pythonhosted.org/packages/81/0a/afa51697e9fb74642f231ea36aca80fa17c8fb89f7a82abd5174023c3960/numpy-2.3.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:067e3d7159a5d8f8a0b46ee11148fc35ca9b21f61e3c49fbd0a027450e65a33b", size = 6647922, upload-time = "2025-09-09T15:56:36.149Z" }, + { url = "https://files.pythonhosted.org/packages/5d/f5/122d9cdb3f51c520d150fef6e87df9279e33d19a9611a87c0d2cf78a89f4/numpy-2.3.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c02d0629d25d426585fb2e45a66154081b9fa677bc92a881ff1d216bc9919a8", size = 14281991, upload-time = "2025-09-09T15:56:40.548Z" }, + { url = "https://files.pythonhosted.org/packages/51/64/7de3c91e821a2debf77c92962ea3fe6ac2bc45d0778c1cbe15d4fce2fd94/numpy-2.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9192da52b9745f7f0766531dcfa978b7763916f158bb63bdb8a1eca0068ab20", size = 16641643, upload-time = "2025-09-09T15:56:43.343Z" }, + { url = "https://files.pythonhosted.org/packages/30/e4/961a5fa681502cd0d68907818b69f67542695b74e3ceaa513918103b7e80/numpy-2.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cd7de500a5b66319db419dc3c345244404a164beae0d0937283b907d8152e6ea", size = 16056787, upload-time = "2025-09-09T15:56:46.141Z" }, + { url = "https://files.pythonhosted.org/packages/99/26/92c912b966e47fbbdf2ad556cb17e3a3088e2e1292b9833be1dfa5361a1a/numpy-2.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:93d4962d8f82af58f0b2eb85daaf1b3ca23fe0a85d0be8f1f2b7bb46034e56d7", size = 18579598, upload-time = "2025-09-09T15:56:49.844Z" }, + { url = "https://files.pythonhosted.org/packages/17/b6/fc8f82cb3520768718834f310c37d96380d9dc61bfdaf05fe5c0b7653e01/numpy-2.3.3-cp312-cp312-win32.whl", hash = "sha256:5534ed6b92f9b7dca6c0a19d6df12d41c68b991cef051d108f6dbff3babc4ebf", size = 6320800, upload-time = "2025-09-09T15:56:52.499Z" }, + { url = "https://files.pythonhosted.org/packages/32/ee/de999f2625b80d043d6d2d628c07d0d5555a677a3cf78fdf868d409b8766/numpy-2.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:497d7cad08e7092dba36e3d296fe4c97708c93daf26643a1ae4b03f6294d30eb", size = 12786615, upload-time = "2025-09-09T15:56:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/49/6e/b479032f8a43559c383acb20816644f5f91c88f633d9271ee84f3b3a996c/numpy-2.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:ca0309a18d4dfea6fc6262a66d06c26cfe4640c3926ceec90e57791a82b6eee5", size = 10195936, upload-time = "2025-09-09T15:56:56.541Z" }, + { url = "https://files.pythonhosted.org/packages/7d/b9/984c2b1ee61a8b803bf63582b4ac4242cf76e2dbd663efeafcb620cc0ccb/numpy-2.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f5415fb78995644253370985342cd03572ef8620b934da27d77377a2285955bf", size = 20949588, upload-time = "2025-09-09T15:56:59.087Z" }, + { url = "https://files.pythonhosted.org/packages/a6/e4/07970e3bed0b1384d22af1e9912527ecbeb47d3b26e9b6a3bced068b3bea/numpy-2.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d00de139a3324e26ed5b95870ce63be7ec7352171bc69a4cf1f157a48e3eb6b7", size = 14177802, upload-time = "2025-09-09T15:57:01.73Z" }, + { url = "https://files.pythonhosted.org/packages/35/c7/477a83887f9de61f1203bad89cf208b7c19cc9fef0cebef65d5a1a0619f2/numpy-2.3.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:9dc13c6a5829610cc07422bc74d3ac083bd8323f14e2827d992f9e52e22cd6a6", size = 5106537, upload-time = "2025-09-09T15:57:03.765Z" }, + { url = "https://files.pythonhosted.org/packages/52/47/93b953bd5866a6f6986344d045a207d3f1cfbad99db29f534ea9cee5108c/numpy-2.3.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:d79715d95f1894771eb4e60fb23f065663b2298f7d22945d66877aadf33d00c7", size = 6640743, upload-time = "2025-09-09T15:57:07.921Z" }, + { url = "https://files.pythonhosted.org/packages/23/83/377f84aaeb800b64c0ef4de58b08769e782edcefa4fea712910b6f0afd3c/numpy-2.3.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:952cfd0748514ea7c3afc729a0fc639e61655ce4c55ab9acfab14bda4f402b4c", size = 14278881, upload-time = "2025-09-09T15:57:11.349Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a5/bf3db6e66c4b160d6ea10b534c381a1955dfab34cb1017ea93aa33c70ed3/numpy-2.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5b83648633d46f77039c29078751f80da65aa64d5622a3cd62aaef9d835b6c93", size = 16636301, upload-time = "2025-09-09T15:57:14.245Z" }, + { url = "https://files.pythonhosted.org/packages/a2/59/1287924242eb4fa3f9b3a2c30400f2e17eb2707020d1c5e3086fe7330717/numpy-2.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b001bae8cea1c7dfdb2ae2b017ed0a6f2102d7a70059df1e338e307a4c78a8ae", size = 16053645, upload-time = "2025-09-09T15:57:16.534Z" }, + { url = "https://files.pythonhosted.org/packages/e6/93/b3d47ed882027c35e94ac2320c37e452a549f582a5e801f2d34b56973c97/numpy-2.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8e9aced64054739037d42fb84c54dd38b81ee238816c948c8f3ed134665dcd86", size = 18578179, upload-time = "2025-09-09T15:57:18.883Z" }, + { url = "https://files.pythonhosted.org/packages/20/d9/487a2bccbf7cc9d4bfc5f0f197761a5ef27ba870f1e3bbb9afc4bbe3fcc2/numpy-2.3.3-cp313-cp313-win32.whl", hash = "sha256:9591e1221db3f37751e6442850429b3aabf7026d3b05542d102944ca7f00c8a8", size = 6312250, upload-time = "2025-09-09T15:57:21.296Z" }, + { url = "https://files.pythonhosted.org/packages/1b/b5/263ebbbbcede85028f30047eab3d58028d7ebe389d6493fc95ae66c636ab/numpy-2.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:f0dadeb302887f07431910f67a14d57209ed91130be0adea2f9793f1a4f817cf", size = 12783269, upload-time = "2025-09-09T15:57:23.034Z" }, + { url = "https://files.pythonhosted.org/packages/fa/75/67b8ca554bbeaaeb3fac2e8bce46967a5a06544c9108ec0cf5cece559b6c/numpy-2.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:3c7cf302ac6e0b76a64c4aecf1a09e51abd9b01fc7feee80f6c43e3ab1b1dbc5", size = 10195314, upload-time = "2025-09-09T15:57:25.045Z" }, + { url = "https://files.pythonhosted.org/packages/11/d0/0d1ddec56b162042ddfafeeb293bac672de9b0cfd688383590090963720a/numpy-2.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:eda59e44957d272846bb407aad19f89dc6f58fecf3504bd144f4c5cf81a7eacc", size = 21048025, upload-time = "2025-09-09T15:57:27.257Z" }, + { url = "https://files.pythonhosted.org/packages/36/9e/1996ca6b6d00415b6acbdd3c42f7f03ea256e2c3f158f80bd7436a8a19f3/numpy-2.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:823d04112bc85ef5c4fda73ba24e6096c8f869931405a80aa8b0e604510a26bc", size = 14301053, upload-time = "2025-09-09T15:57:30.077Z" }, + { url = "https://files.pythonhosted.org/packages/05/24/43da09aa764c68694b76e84b3d3f0c44cb7c18cdc1ba80e48b0ac1d2cd39/numpy-2.3.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:40051003e03db4041aa325da2a0971ba41cf65714e65d296397cc0e32de6018b", size = 5229444, upload-time = "2025-09-09T15:57:32.733Z" }, + { url = "https://files.pythonhosted.org/packages/bc/14/50ffb0f22f7218ef8af28dd089f79f68289a7a05a208db9a2c5dcbe123c1/numpy-2.3.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:6ee9086235dd6ab7ae75aba5662f582a81ced49f0f1c6de4260a78d8f2d91a19", size = 6738039, upload-time = "2025-09-09T15:57:34.328Z" }, + { url = "https://files.pythonhosted.org/packages/55/52/af46ac0795e09657d45a7f4db961917314377edecf66db0e39fa7ab5c3d3/numpy-2.3.3-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94fcaa68757c3e2e668ddadeaa86ab05499a70725811e582b6a9858dd472fb30", size = 14352314, upload-time = "2025-09-09T15:57:36.255Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b1/dc226b4c90eb9f07a3fff95c2f0db3268e2e54e5cce97c4ac91518aee71b/numpy-2.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da1a74b90e7483d6ce5244053399a614b1d6b7bc30a60d2f570e5071f8959d3e", size = 16701722, upload-time = "2025-09-09T15:57:38.622Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9d/9d8d358f2eb5eced14dba99f110d83b5cd9a4460895230f3b396ad19a323/numpy-2.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2990adf06d1ecee3b3dcbb4977dfab6e9f09807598d647f04d385d29e7a3c3d3", size = 16132755, upload-time = "2025-09-09T15:57:41.16Z" }, + { url = "https://files.pythonhosted.org/packages/b6/27/b3922660c45513f9377b3fb42240bec63f203c71416093476ec9aa0719dc/numpy-2.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ed635ff692483b8e3f0fcaa8e7eb8a75ee71aa6d975388224f70821421800cea", size = 18651560, upload-time = "2025-09-09T15:57:43.459Z" }, + { url = "https://files.pythonhosted.org/packages/5b/8e/3ab61a730bdbbc201bb245a71102aa609f0008b9ed15255500a99cd7f780/numpy-2.3.3-cp313-cp313t-win32.whl", hash = "sha256:a333b4ed33d8dc2b373cc955ca57babc00cd6f9009991d9edc5ddbc1bac36bcd", size = 6442776, upload-time = "2025-09-09T15:57:45.793Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3a/e22b766b11f6030dc2decdeff5c2fb1610768055603f9f3be88b6d192fb2/numpy-2.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:4384a169c4d8f97195980815d6fcad04933a7e1ab3b530921c3fef7a1c63426d", size = 12927281, upload-time = "2025-09-09T15:57:47.492Z" }, + { url = "https://files.pythonhosted.org/packages/7b/42/c2e2bc48c5e9b2a83423f99733950fbefd86f165b468a3d85d52b30bf782/numpy-2.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:75370986cc0bc66f4ce5110ad35aae6d182cc4ce6433c40ad151f53690130bf1", size = 10265275, upload-time = "2025-09-09T15:57:49.647Z" }, + { url = "https://files.pythonhosted.org/packages/6b/01/342ad585ad82419b99bcf7cebe99e61da6bedb89e213c5fd71acc467faee/numpy-2.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:cd052f1fa6a78dee696b58a914b7229ecfa41f0a6d96dc663c1220a55e137593", size = 20951527, upload-time = "2025-09-09T15:57:52.006Z" }, + { url = "https://files.pythonhosted.org/packages/ef/d8/204e0d73fc1b7a9ee80ab1fe1983dd33a4d64a4e30a05364b0208e9a241a/numpy-2.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:414a97499480067d305fcac9716c29cf4d0d76db6ebf0bf3cbce666677f12652", size = 14186159, upload-time = "2025-09-09T15:57:54.407Z" }, + { url = "https://files.pythonhosted.org/packages/22/af/f11c916d08f3a18fb8ba81ab72b5b74a6e42ead4c2846d270eb19845bf74/numpy-2.3.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:50a5fe69f135f88a2be9b6ca0481a68a136f6febe1916e4920e12f1a34e708a7", size = 5114624, upload-time = "2025-09-09T15:57:56.5Z" }, + { url = "https://files.pythonhosted.org/packages/fb/11/0ed919c8381ac9d2ffacd63fd1f0c34d27e99cab650f0eb6f110e6ae4858/numpy-2.3.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:b912f2ed2b67a129e6a601e9d93d4fa37bef67e54cac442a2f588a54afe5c67a", size = 6642627, upload-time = "2025-09-09T15:57:58.206Z" }, + { url = "https://files.pythonhosted.org/packages/ee/83/deb5f77cb0f7ba6cb52b91ed388b47f8f3c2e9930d4665c600408d9b90b9/numpy-2.3.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9e318ee0596d76d4cb3d78535dc005fa60e5ea348cd131a51e99d0bdbe0b54fe", size = 14296926, upload-time = "2025-09-09T15:58:00.035Z" }, + { url = "https://files.pythonhosted.org/packages/77/cc/70e59dcb84f2b005d4f306310ff0a892518cc0c8000a33d0e6faf7ca8d80/numpy-2.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce020080e4a52426202bdb6f7691c65bb55e49f261f31a8f506c9f6bc7450421", size = 16638958, upload-time = "2025-09-09T15:58:02.738Z" }, + { url = "https://files.pythonhosted.org/packages/b6/5a/b2ab6c18b4257e099587d5b7f903317bd7115333ad8d4ec4874278eafa61/numpy-2.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e6687dc183aa55dae4a705b35f9c0f8cb178bcaa2f029b241ac5356221d5c021", size = 16071920, upload-time = "2025-09-09T15:58:05.029Z" }, + { url = "https://files.pythonhosted.org/packages/b8/f1/8b3fdc44324a259298520dd82147ff648979bed085feeacc1250ef1656c0/numpy-2.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d8f3b1080782469fdc1718c4ed1d22549b5fb12af0d57d35e992158a772a37cf", size = 18577076, upload-time = "2025-09-09T15:58:07.745Z" }, + { url = "https://files.pythonhosted.org/packages/f0/a1/b87a284fb15a42e9274e7fcea0dad259d12ddbf07c1595b26883151ca3b4/numpy-2.3.3-cp314-cp314-win32.whl", hash = "sha256:cb248499b0bc3be66ebd6578b83e5acacf1d6cb2a77f2248ce0e40fbec5a76d0", size = 6366952, upload-time = "2025-09-09T15:58:10.096Z" }, + { url = "https://files.pythonhosted.org/packages/70/5f/1816f4d08f3b8f66576d8433a66f8fa35a5acfb3bbd0bf6c31183b003f3d/numpy-2.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:691808c2b26b0f002a032c73255d0bd89751425f379f7bcd22d140db593a96e8", size = 12919322, upload-time = "2025-09-09T15:58:12.138Z" }, + { url = "https://files.pythonhosted.org/packages/8c/de/072420342e46a8ea41c324a555fa90fcc11637583fb8df722936aed1736d/numpy-2.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:9ad12e976ca7b10f1774b03615a2a4bab8addce37ecc77394d8e986927dc0dfe", size = 10478630, upload-time = "2025-09-09T15:58:14.64Z" }, + { url = "https://files.pythonhosted.org/packages/d5/df/ee2f1c0a9de7347f14da5dd3cd3c3b034d1b8607ccb6883d7dd5c035d631/numpy-2.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9cc48e09feb11e1db00b320e9d30a4151f7369afb96bd0e48d942d09da3a0d00", size = 21047987, upload-time = "2025-09-09T15:58:16.889Z" }, + { url = "https://files.pythonhosted.org/packages/d6/92/9453bdc5a4e9e69cf4358463f25e8260e2ffc126d52e10038b9077815989/numpy-2.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:901bf6123879b7f251d3631967fd574690734236075082078e0571977c6a8e6a", size = 14301076, upload-time = "2025-09-09T15:58:20.343Z" }, + { url = "https://files.pythonhosted.org/packages/13/77/1447b9eb500f028bb44253105bd67534af60499588a5149a94f18f2ca917/numpy-2.3.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:7f025652034199c301049296b59fa7d52c7e625017cae4c75d8662e377bf487d", size = 5229491, upload-time = "2025-09-09T15:58:22.481Z" }, + { url = "https://files.pythonhosted.org/packages/3d/f9/d72221b6ca205f9736cb4b2ce3b002f6e45cd67cd6a6d1c8af11a2f0b649/numpy-2.3.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:533ca5f6d325c80b6007d4d7fb1984c303553534191024ec6a524a4c92a5935a", size = 6737913, upload-time = "2025-09-09T15:58:24.569Z" }, + { url = "https://files.pythonhosted.org/packages/3c/5f/d12834711962ad9c46af72f79bb31e73e416ee49d17f4c797f72c96b6ca5/numpy-2.3.3-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0edd58682a399824633b66885d699d7de982800053acf20be1eaa46d92009c54", size = 14352811, upload-time = "2025-09-09T15:58:26.416Z" }, + { url = "https://files.pythonhosted.org/packages/a1/0d/fdbec6629d97fd1bebed56cd742884e4eead593611bbe1abc3eb40d304b2/numpy-2.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:367ad5d8fbec5d9296d18478804a530f1191e24ab4d75ab408346ae88045d25e", size = 16702689, upload-time = "2025-09-09T15:58:28.831Z" }, + { url = "https://files.pythonhosted.org/packages/9b/09/0a35196dc5575adde1eb97ddfbc3e1687a814f905377621d18ca9bc2b7dd/numpy-2.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8f6ac61a217437946a1fa48d24c47c91a0c4f725237871117dea264982128097", size = 16133855, upload-time = "2025-09-09T15:58:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/7a/ca/c9de3ea397d576f1b6753eaa906d4cdef1bf97589a6d9825a349b4729cc2/numpy-2.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:179a42101b845a816d464b6fe9a845dfaf308fdfc7925387195570789bb2c970", size = 18652520, upload-time = "2025-09-09T15:58:33.762Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c2/e5ed830e08cd0196351db55db82f65bc0ab05da6ef2b72a836dcf1936d2f/numpy-2.3.3-cp314-cp314t-win32.whl", hash = "sha256:1250c5d3d2562ec4174bce2e3a1523041595f9b651065e4a4473f5f48a6bc8a5", size = 6515371, upload-time = "2025-09-09T15:58:36.04Z" }, + { url = "https://files.pythonhosted.org/packages/47/c7/b0f6b5b67f6788a0725f744496badbb604d226bf233ba716683ebb47b570/numpy-2.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b37a0b2e5935409daebe82c1e42274d30d9dd355852529eab91dab8dcca7419f", size = 13112576, upload-time = "2025-09-09T15:58:37.927Z" }, + { url = "https://files.pythonhosted.org/packages/06/b9/33bba5ff6fb679aa0b1f8a07e853f002a6b04b9394db3069a1270a7784ca/numpy-2.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:78c9f6560dc7e6b3990e32df7ea1a50bbd0e2a111e05209963f5ddcab7073b0b", size = 10545953, upload-time = "2025-09-09T15:58:40.576Z" }, +] + +[[package]] +name = "packaging" +version = "25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, +] + +[[package]] +name = "pandas" +version = "2.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/8e/0e90233ac205ad182bd6b422532695d2b9414944a280488105d598c70023/pandas-2.3.2.tar.gz", hash = "sha256:ab7b58f8f82706890924ccdfb5f48002b83d2b5a3845976a9fb705d36c34dcdb", size = 4488684, upload-time = "2025-08-21T10:28:29.257Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/db/614c20fb7a85a14828edd23f1c02db58a30abf3ce76f38806155d160313c/pandas-2.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fbb977f802156e7a3f829e9d1d5398f6192375a3e2d1a9ee0803e35fe70a2b9", size = 11587652, upload-time = "2025-08-21T10:27:15.888Z" }, + { url = "https://files.pythonhosted.org/packages/99/b0/756e52f6582cade5e746f19bad0517ff27ba9c73404607c0306585c201b3/pandas-2.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1b9b52693123dd234b7c985c68b709b0b009f4521000d0525f2b95c22f15944b", size = 10717686, upload-time = "2025-08-21T10:27:18.486Z" }, + { url = "https://files.pythonhosted.org/packages/37/4c/dd5ccc1e357abfeee8353123282de17997f90ff67855f86154e5a13b81e5/pandas-2.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bd281310d4f412733f319a5bc552f86d62cddc5f51d2e392c8787335c994175", size = 11278722, upload-time = "2025-08-21T10:27:21.149Z" }, + { url = "https://files.pythonhosted.org/packages/d3/a4/f7edcfa47e0a88cda0be8b068a5bae710bf264f867edfdf7b71584ace362/pandas-2.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:96d31a6b4354e3b9b8a2c848af75d31da390657e3ac6f30c05c82068b9ed79b9", size = 11987803, upload-time = "2025-08-21T10:27:23.767Z" }, + { url = "https://files.pythonhosted.org/packages/f6/61/1bce4129f93ab66f1c68b7ed1c12bac6a70b1b56c5dab359c6bbcd480b52/pandas-2.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:df4df0b9d02bb873a106971bb85d448378ef14b86ba96f035f50bbd3688456b4", size = 12766345, upload-time = "2025-08-21T10:27:26.6Z" }, + { url = "https://files.pythonhosted.org/packages/8e/46/80d53de70fee835531da3a1dae827a1e76e77a43ad22a8cd0f8142b61587/pandas-2.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:213a5adf93d020b74327cb2c1b842884dbdd37f895f42dcc2f09d451d949f811", size = 13439314, upload-time = "2025-08-21T10:27:29.213Z" }, + { url = "https://files.pythonhosted.org/packages/28/30/8114832daff7489f179971dbc1d854109b7f4365a546e3ea75b6516cea95/pandas-2.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:8c13b81a9347eb8c7548f53fd9a4f08d4dfe996836543f805c987bafa03317ae", size = 10983326, upload-time = "2025-08-21T10:27:31.901Z" }, + { url = "https://files.pythonhosted.org/packages/27/64/a2f7bf678af502e16b472527735d168b22b7824e45a4d7e96a4fbb634b59/pandas-2.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0c6ecbac99a354a051ef21c5307601093cb9e0f4b1855984a084bfec9302699e", size = 11531061, upload-time = "2025-08-21T10:27:34.647Z" }, + { url = "https://files.pythonhosted.org/packages/54/4c/c3d21b2b7769ef2f4c2b9299fcadd601efa6729f1357a8dbce8dd949ed70/pandas-2.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c6f048aa0fd080d6a06cc7e7537c09b53be6642d330ac6f54a600c3ace857ee9", size = 10668666, upload-time = "2025-08-21T10:27:37.203Z" }, + { url = "https://files.pythonhosted.org/packages/50/e2/f775ba76ecfb3424d7f5862620841cf0edb592e9abd2d2a5387d305fe7a8/pandas-2.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0064187b80a5be6f2f9c9d6bdde29372468751dfa89f4211a3c5871854cfbf7a", size = 11332835, upload-time = "2025-08-21T10:27:40.188Z" }, + { url = "https://files.pythonhosted.org/packages/8f/52/0634adaace9be2d8cac9ef78f05c47f3a675882e068438b9d7ec7ef0c13f/pandas-2.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ac8c320bded4718b298281339c1a50fb00a6ba78cb2a63521c39bec95b0209b", size = 12057211, upload-time = "2025-08-21T10:27:43.117Z" }, + { url = "https://files.pythonhosted.org/packages/0b/9d/2df913f14b2deb9c748975fdb2491da1a78773debb25abbc7cbc67c6b549/pandas-2.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:114c2fe4f4328cf98ce5716d1532f3ab79c5919f95a9cfee81d9140064a2e4d6", size = 12749277, upload-time = "2025-08-21T10:27:45.474Z" }, + { url = "https://files.pythonhosted.org/packages/87/af/da1a2417026bd14d98c236dba88e39837182459d29dcfcea510b2ac9e8a1/pandas-2.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:48fa91c4dfb3b2b9bfdb5c24cd3567575f4e13f9636810462ffed8925352be5a", size = 13415256, upload-time = "2025-08-21T10:27:49.885Z" }, + { url = "https://files.pythonhosted.org/packages/22/3c/f2af1ce8840ef648584a6156489636b5692c162771918aa95707c165ad2b/pandas-2.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:12d039facec710f7ba305786837d0225a3444af7bbd9c15c32ca2d40d157ed8b", size = 10982579, upload-time = "2025-08-21T10:28:08.435Z" }, + { url = "https://files.pythonhosted.org/packages/f3/98/8df69c4097a6719e357dc249bf437b8efbde808038268e584421696cbddf/pandas-2.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:c624b615ce97864eb588779ed4046186f967374185c047070545253a52ab2d57", size = 12028163, upload-time = "2025-08-21T10:27:52.232Z" }, + { url = "https://files.pythonhosted.org/packages/0e/23/f95cbcbea319f349e10ff90db488b905c6883f03cbabd34f6b03cbc3c044/pandas-2.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0cee69d583b9b128823d9514171cabb6861e09409af805b54459bd0c821a35c2", size = 11391860, upload-time = "2025-08-21T10:27:54.673Z" }, + { url = "https://files.pythonhosted.org/packages/ad/1b/6a984e98c4abee22058aa75bfb8eb90dce58cf8d7296f8bc56c14bc330b0/pandas-2.3.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2319656ed81124982900b4c37f0e0c58c015af9a7bbc62342ba5ad07ace82ba9", size = 11309830, upload-time = "2025-08-21T10:27:56.957Z" }, + { url = "https://files.pythonhosted.org/packages/15/d5/f0486090eb18dd8710bf60afeaf638ba6817047c0c8ae5c6a25598665609/pandas-2.3.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b37205ad6f00d52f16b6d09f406434ba928c1a1966e2771006a9033c736d30d2", size = 11883216, upload-time = "2025-08-21T10:27:59.302Z" }, + { url = "https://files.pythonhosted.org/packages/10/86/692050c119696da19e20245bbd650d8dfca6ceb577da027c3a73c62a047e/pandas-2.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:837248b4fc3a9b83b9c6214699a13f069dc13510a6a6d7f9ba33145d2841a012", size = 12699743, upload-time = "2025-08-21T10:28:02.447Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d7/612123674d7b17cf345aad0a10289b2a384bff404e0463a83c4a3a59d205/pandas-2.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d2c3554bd31b731cd6490d94a28f3abb8dd770634a9e06eb6d2911b9827db370", size = 13186141, upload-time = "2025-08-21T10:28:05.377Z" }, +] + +[[package]] +name = "parso" +version = "0.8.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/de/53e0bcf53d13e005bd8c92e7855142494f41171b34c2536b86187474184d/parso-0.8.5.tar.gz", hash = "sha256:034d7354a9a018bdce352f48b2a8a450f05e9d6ee85db84764e9b6bd96dafe5a", size = 401205, upload-time = "2025-08-23T15:15:28.028Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/32/f8e3c85d1d5250232a5d3477a2a28cc291968ff175caeadaf3cc19ce0e4a/parso-0.8.5-py2.py3-none-any.whl", hash = "sha256:646204b5ee239c396d040b90f9e272e9a8017c630092bf59980beb62fd033887", size = 106668, upload-time = "2025-08-23T15:15:25.663Z" }, +] + +[[package]] +name = "passlib" +version = "1.7.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b6/06/9da9ee59a67fae7761aab3ccc84fa4f3f33f125b370f1ccdb915bf967c11/passlib-1.7.4.tar.gz", hash = "sha256:defd50f72b65c5402ab2c573830a6978e5f202ad0d984793c8dde2c4152ebe04", size = 689844, upload-time = "2020-10-08T19:00:52.121Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/a4/ab6b7589382ca3df236e03faa71deac88cae040af60c071a78d254a62172/passlib-1.7.4-py2.py3-none-any.whl", hash = "sha256:aa6bca462b8d8bda89c70b382f0c298a20b5560af6cbfa2dce410c0a2fb669f1", size = 525554, upload-time = "2020-10-08T19:00:49.856Z" }, +] + +[[package]] +name = "pathspec" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + +[[package]] +name = "pillow" +version = "11.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3d6767bb38a8fc10e33796ba4ba210cbab9354b6d238/pillow-11.3.0.tar.gz", hash = "sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523", size = 47113069, upload-time = "2025-07-01T09:16:30.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/fe/1bc9b3ee13f68487a99ac9529968035cca2f0a51ec36892060edcc51d06a/pillow-11.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdae223722da47b024b867c1ea0be64e0df702c5e0a60e27daad39bf960dd1e4", size = 5278800, upload-time = "2025-07-01T09:14:17.648Z" }, + { url = "https://files.pythonhosted.org/packages/2c/32/7e2ac19b5713657384cec55f89065fb306b06af008cfd87e572035b27119/pillow-11.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:921bd305b10e82b4d1f5e802b6850677f965d8394203d182f078873851dada69", size = 4686296, upload-time = "2025-07-01T09:14:19.828Z" }, + { url = "https://files.pythonhosted.org/packages/8e/1e/b9e12bbe6e4c2220effebc09ea0923a07a6da1e1f1bfbc8d7d29a01ce32b/pillow-11.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb76541cba2f958032d79d143b98a3a6b3ea87f0959bbe256c0b5e416599fd5d", size = 5871726, upload-time = "2025-07-03T13:10:04.448Z" }, + { url = "https://files.pythonhosted.org/packages/8d/33/e9200d2bd7ba00dc3ddb78df1198a6e80d7669cce6c2bdbeb2530a74ec58/pillow-11.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67172f2944ebba3d4a7b54f2e95c786a3a50c21b88456329314caaa28cda70f6", size = 7644652, upload-time = "2025-07-03T13:10:10.391Z" }, + { url = "https://files.pythonhosted.org/packages/41/f1/6f2427a26fc683e00d985bc391bdd76d8dd4e92fac33d841127eb8fb2313/pillow-11.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f07ed9f56a3b9b5f49d3661dc9607484e85c67e27f3e8be2c7d28ca032fec7", size = 5977787, upload-time = "2025-07-01T09:14:21.63Z" }, + { url = "https://files.pythonhosted.org/packages/e4/c9/06dd4a38974e24f932ff5f98ea3c546ce3f8c995d3f0985f8e5ba48bba19/pillow-11.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:676b2815362456b5b3216b4fd5bd89d362100dc6f4945154ff172e206a22c024", size = 6645236, upload-time = "2025-07-01T09:14:23.321Z" }, + { url = "https://files.pythonhosted.org/packages/40/e7/848f69fb79843b3d91241bad658e9c14f39a32f71a301bcd1d139416d1be/pillow-11.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3e184b2f26ff146363dd07bde8b711833d7b0202e27d13540bfe2e35a323a809", size = 6086950, upload-time = "2025-07-01T09:14:25.237Z" }, + { url = "https://files.pythonhosted.org/packages/0b/1a/7cff92e695a2a29ac1958c2a0fe4c0b2393b60aac13b04a4fe2735cad52d/pillow-11.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6be31e3fc9a621e071bc17bb7de63b85cbe0bfae91bb0363c893cbe67247780d", size = 6723358, upload-time = "2025-07-01T09:14:27.053Z" }, + { url = "https://files.pythonhosted.org/packages/26/7d/73699ad77895f69edff76b0f332acc3d497f22f5d75e5360f78cbcaff248/pillow-11.3.0-cp312-cp312-win32.whl", hash = "sha256:7b161756381f0918e05e7cb8a371fff367e807770f8fe92ecb20d905d0e1c149", size = 6275079, upload-time = "2025-07-01T09:14:30.104Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ce/e7dfc873bdd9828f3b6e5c2bbb74e47a98ec23cc5c74fc4e54462f0d9204/pillow-11.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a6444696fce635783440b7f7a9fc24b3ad10a9ea3f0ab66c5905be1c19ccf17d", size = 6986324, upload-time = "2025-07-01T09:14:31.899Z" }, + { url = "https://files.pythonhosted.org/packages/16/8f/b13447d1bf0b1f7467ce7d86f6e6edf66c0ad7cf44cf5c87a37f9bed9936/pillow-11.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:2aceea54f957dd4448264f9bf40875da0415c83eb85f55069d89c0ed436e3542", size = 2423067, upload-time = "2025-07-01T09:14:33.709Z" }, + { url = "https://files.pythonhosted.org/packages/1e/93/0952f2ed8db3a5a4c7a11f91965d6184ebc8cd7cbb7941a260d5f018cd2d/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:1c627742b539bba4309df89171356fcb3cc5a9178355b2727d1b74a6cf155fbd", size = 2128328, upload-time = "2025-07-01T09:14:35.276Z" }, + { url = "https://files.pythonhosted.org/packages/4b/e8/100c3d114b1a0bf4042f27e0f87d2f25e857e838034e98ca98fe7b8c0a9c/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:30b7c02f3899d10f13d7a48163c8969e4e653f8b43416d23d13d1bbfdc93b9f8", size = 2170652, upload-time = "2025-07-01T09:14:37.203Z" }, + { url = "https://files.pythonhosted.org/packages/aa/86/3f758a28a6e381758545f7cdb4942e1cb79abd271bea932998fc0db93cb6/pillow-11.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7859a4cc7c9295f5838015d8cc0a9c215b77e43d07a25e460f35cf516df8626f", size = 2227443, upload-time = "2025-07-01T09:14:39.344Z" }, + { url = "https://files.pythonhosted.org/packages/01/f4/91d5b3ffa718df2f53b0dc109877993e511f4fd055d7e9508682e8aba092/pillow-11.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec1ee50470b0d050984394423d96325b744d55c701a439d2bd66089bff963d3c", size = 5278474, upload-time = "2025-07-01T09:14:41.843Z" }, + { url = "https://files.pythonhosted.org/packages/f9/0e/37d7d3eca6c879fbd9dba21268427dffda1ab00d4eb05b32923d4fbe3b12/pillow-11.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7db51d222548ccfd274e4572fdbf3e810a5e66b00608862f947b163e613b67dd", size = 4686038, upload-time = "2025-07-01T09:14:44.008Z" }, + { url = "https://files.pythonhosted.org/packages/ff/b0/3426e5c7f6565e752d81221af9d3676fdbb4f352317ceafd42899aaf5d8a/pillow-11.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2d6fcc902a24ac74495df63faad1884282239265c6839a0a6416d33faedfae7e", size = 5864407, upload-time = "2025-07-03T13:10:15.628Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c1/c6c423134229f2a221ee53f838d4be9d82bab86f7e2f8e75e47b6bf6cd77/pillow-11.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0f5d8f4a08090c6d6d578351a2b91acf519a54986c055af27e7a93feae6d3f1", size = 7639094, upload-time = "2025-07-03T13:10:21.857Z" }, + { url = "https://files.pythonhosted.org/packages/ba/c9/09e6746630fe6372c67c648ff9deae52a2bc20897d51fa293571977ceb5d/pillow-11.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c37d8ba9411d6003bba9e518db0db0c58a680ab9fe5179f040b0463644bc9805", size = 5973503, upload-time = "2025-07-01T09:14:45.698Z" }, + { url = "https://files.pythonhosted.org/packages/d5/1c/a2a29649c0b1983d3ef57ee87a66487fdeb45132df66ab30dd37f7dbe162/pillow-11.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13f87d581e71d9189ab21fe0efb5a23e9f28552d5be6979e84001d3b8505abe8", size = 6642574, upload-time = "2025-07-01T09:14:47.415Z" }, + { url = "https://files.pythonhosted.org/packages/36/de/d5cc31cc4b055b6c6fd990e3e7f0f8aaf36229a2698501bcb0cdf67c7146/pillow-11.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:023f6d2d11784a465f09fd09a34b150ea4672e85fb3d05931d89f373ab14abb2", size = 6084060, upload-time = "2025-07-01T09:14:49.636Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ea/502d938cbaeec836ac28a9b730193716f0114c41325db428e6b280513f09/pillow-11.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:45dfc51ac5975b938e9809451c51734124e73b04d0f0ac621649821a63852e7b", size = 6721407, upload-time = "2025-07-01T09:14:51.962Z" }, + { url = "https://files.pythonhosted.org/packages/45/9c/9c5e2a73f125f6cbc59cc7087c8f2d649a7ae453f83bd0362ff7c9e2aee2/pillow-11.3.0-cp313-cp313-win32.whl", hash = "sha256:a4d336baed65d50d37b88ca5b60c0fa9d81e3a87d4a7930d3880d1624d5b31f3", size = 6273841, upload-time = "2025-07-01T09:14:54.142Z" }, + { url = "https://files.pythonhosted.org/packages/23/85/397c73524e0cd212067e0c969aa245b01d50183439550d24d9f55781b776/pillow-11.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bce5c4fd0921f99d2e858dc4d4d64193407e1b99478bc5cacecba2311abde51", size = 6978450, upload-time = "2025-07-01T09:14:56.436Z" }, + { url = "https://files.pythonhosted.org/packages/17/d2/622f4547f69cd173955194b78e4d19ca4935a1b0f03a302d655c9f6aae65/pillow-11.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:1904e1264881f682f02b7f8167935cce37bc97db457f8e7849dc3a6a52b99580", size = 2423055, upload-time = "2025-07-01T09:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/dd/80/a8a2ac21dda2e82480852978416cfacd439a4b490a501a288ecf4fe2532d/pillow-11.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4c834a3921375c48ee6b9624061076bc0a32a60b5532b322cc0ea64e639dd50e", size = 5281110, upload-time = "2025-07-01T09:14:59.79Z" }, + { url = "https://files.pythonhosted.org/packages/44/d6/b79754ca790f315918732e18f82a8146d33bcd7f4494380457ea89eb883d/pillow-11.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e05688ccef30ea69b9317a9ead994b93975104a677a36a8ed8106be9260aa6d", size = 4689547, upload-time = "2025-07-01T09:15:01.648Z" }, + { url = "https://files.pythonhosted.org/packages/49/20/716b8717d331150cb00f7fdd78169c01e8e0c219732a78b0e59b6bdb2fd6/pillow-11.3.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1019b04af07fc0163e2810167918cb5add8d74674b6267616021ab558dc98ced", size = 5901554, upload-time = "2025-07-03T13:10:27.018Z" }, + { url = "https://files.pythonhosted.org/packages/74/cf/a9f3a2514a65bb071075063a96f0a5cf949c2f2fce683c15ccc83b1c1cab/pillow-11.3.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f944255db153ebb2b19c51fe85dd99ef0ce494123f21b9db4877ffdfc5590c7c", size = 7669132, upload-time = "2025-07-03T13:10:33.01Z" }, + { url = "https://files.pythonhosted.org/packages/98/3c/da78805cbdbee9cb43efe8261dd7cc0b4b93f2ac79b676c03159e9db2187/pillow-11.3.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f85acb69adf2aaee8b7da124efebbdb959a104db34d3a2cb0f3793dbae422a8", size = 6005001, upload-time = "2025-07-01T09:15:03.365Z" }, + { url = "https://files.pythonhosted.org/packages/6c/fa/ce044b91faecf30e635321351bba32bab5a7e034c60187fe9698191aef4f/pillow-11.3.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05f6ecbeff5005399bb48d198f098a9b4b6bdf27b8487c7f38ca16eeb070cd59", size = 6668814, upload-time = "2025-07-01T09:15:05.655Z" }, + { url = "https://files.pythonhosted.org/packages/7b/51/90f9291406d09bf93686434f9183aba27b831c10c87746ff49f127ee80cb/pillow-11.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a7bc6e6fd0395bc052f16b1a8670859964dbd7003bd0af2ff08342eb6e442cfe", size = 6113124, upload-time = "2025-07-01T09:15:07.358Z" }, + { url = "https://files.pythonhosted.org/packages/cd/5a/6fec59b1dfb619234f7636d4157d11fb4e196caeee220232a8d2ec48488d/pillow-11.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83e1b0161c9d148125083a35c1c5a89db5b7054834fd4387499e06552035236c", size = 6747186, upload-time = "2025-07-01T09:15:09.317Z" }, + { url = "https://files.pythonhosted.org/packages/49/6b/00187a044f98255225f172de653941e61da37104a9ea60e4f6887717e2b5/pillow-11.3.0-cp313-cp313t-win32.whl", hash = "sha256:2a3117c06b8fb646639dce83694f2f9eac405472713fcb1ae887469c0d4f6788", size = 6277546, upload-time = "2025-07-01T09:15:11.311Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5c/6caaba7e261c0d75bab23be79f1d06b5ad2a2ae49f028ccec801b0e853d6/pillow-11.3.0-cp313-cp313t-win_amd64.whl", hash = "sha256:857844335c95bea93fb39e0fa2726b4d9d758850b34075a7e3ff4f4fa3aa3b31", size = 6985102, upload-time = "2025-07-01T09:15:13.164Z" }, + { url = "https://files.pythonhosted.org/packages/f3/7e/b623008460c09a0cb38263c93b828c666493caee2eb34ff67f778b87e58c/pillow-11.3.0-cp313-cp313t-win_arm64.whl", hash = "sha256:8797edc41f3e8536ae4b10897ee2f637235c94f27404cac7297f7b607dd0716e", size = 2424803, upload-time = "2025-07-01T09:15:15.695Z" }, + { url = "https://files.pythonhosted.org/packages/73/f4/04905af42837292ed86cb1b1dabe03dce1edc008ef14c473c5c7e1443c5d/pillow-11.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d9da3df5f9ea2a89b81bb6087177fb1f4d1c7146d583a3fe5c672c0d94e55e12", size = 5278520, upload-time = "2025-07-01T09:15:17.429Z" }, + { url = "https://files.pythonhosted.org/packages/41/b0/33d79e377a336247df6348a54e6d2a2b85d644ca202555e3faa0cf811ecc/pillow-11.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0b275ff9b04df7b640c59ec5a3cb113eefd3795a8df80bac69646ef699c6981a", size = 4686116, upload-time = "2025-07-01T09:15:19.423Z" }, + { url = "https://files.pythonhosted.org/packages/49/2d/ed8bc0ab219ae8768f529597d9509d184fe8a6c4741a6864fea334d25f3f/pillow-11.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0743841cabd3dba6a83f38a92672cccbd69af56e3e91777b0ee7f4dba4385632", size = 5864597, upload-time = "2025-07-03T13:10:38.404Z" }, + { url = "https://files.pythonhosted.org/packages/b5/3d/b932bb4225c80b58dfadaca9d42d08d0b7064d2d1791b6a237f87f661834/pillow-11.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2465a69cf967b8b49ee1b96d76718cd98c4e925414ead59fdf75cf0fd07df673", size = 7638246, upload-time = "2025-07-03T13:10:44.987Z" }, + { url = "https://files.pythonhosted.org/packages/09/b5/0487044b7c096f1b48f0d7ad416472c02e0e4bf6919541b111efd3cae690/pillow-11.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41742638139424703b4d01665b807c6468e23e699e8e90cffefe291c5832b027", size = 5973336, upload-time = "2025-07-01T09:15:21.237Z" }, + { url = "https://files.pythonhosted.org/packages/a8/2d/524f9318f6cbfcc79fbc004801ea6b607ec3f843977652fdee4857a7568b/pillow-11.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93efb0b4de7e340d99057415c749175e24c8864302369e05914682ba642e5d77", size = 6642699, upload-time = "2025-07-01T09:15:23.186Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d2/a9a4f280c6aefedce1e8f615baaa5474e0701d86dd6f1dede66726462bbd/pillow-11.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7966e38dcd0fa11ca390aed7c6f20454443581d758242023cf36fcb319b1a874", size = 6083789, upload-time = "2025-07-01T09:15:25.1Z" }, + { url = "https://files.pythonhosted.org/packages/fe/54/86b0cd9dbb683a9d5e960b66c7379e821a19be4ac5810e2e5a715c09a0c0/pillow-11.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:98a9afa7b9007c67ed84c57c9e0ad86a6000da96eaa638e4f8abe5b65ff83f0a", size = 6720386, upload-time = "2025-07-01T09:15:27.378Z" }, + { url = "https://files.pythonhosted.org/packages/e7/95/88efcaf384c3588e24259c4203b909cbe3e3c2d887af9e938c2022c9dd48/pillow-11.3.0-cp314-cp314-win32.whl", hash = "sha256:02a723e6bf909e7cea0dac1b0e0310be9d7650cd66222a5f1c571455c0a45214", size = 6370911, upload-time = "2025-07-01T09:15:29.294Z" }, + { url = "https://files.pythonhosted.org/packages/2e/cc/934e5820850ec5eb107e7b1a72dd278140731c669f396110ebc326f2a503/pillow-11.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:a418486160228f64dd9e9efcd132679b7a02a5f22c982c78b6fc7dab3fefb635", size = 7117383, upload-time = "2025-07-01T09:15:31.128Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e9/9c0a616a71da2a5d163aa37405e8aced9a906d574b4a214bede134e731bc/pillow-11.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:155658efb5e044669c08896c0c44231c5e9abcaadbc5cd3648df2f7c0b96b9a6", size = 2511385, upload-time = "2025-07-01T09:15:33.328Z" }, + { url = "https://files.pythonhosted.org/packages/1a/33/c88376898aff369658b225262cd4f2659b13e8178e7534df9e6e1fa289f6/pillow-11.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:59a03cdf019efbfeeed910bf79c7c93255c3d54bc45898ac2a4140071b02b4ae", size = 5281129, upload-time = "2025-07-01T09:15:35.194Z" }, + { url = "https://files.pythonhosted.org/packages/1f/70/d376247fb36f1844b42910911c83a02d5544ebd2a8bad9efcc0f707ea774/pillow-11.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f8a5827f84d973d8636e9dc5764af4f0cf2318d26744b3d902931701b0d46653", size = 4689580, upload-time = "2025-07-01T09:15:37.114Z" }, + { url = "https://files.pythonhosted.org/packages/eb/1c/537e930496149fbac69efd2fc4329035bbe2e5475b4165439e3be9cb183b/pillow-11.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ee92f2fd10f4adc4b43d07ec5e779932b4eb3dbfbc34790ada5a6669bc095aa6", size = 5902860, upload-time = "2025-07-03T13:10:50.248Z" }, + { url = "https://files.pythonhosted.org/packages/bd/57/80f53264954dcefeebcf9dae6e3eb1daea1b488f0be8b8fef12f79a3eb10/pillow-11.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c96d333dcf42d01f47b37e0979b6bd73ec91eae18614864622d9b87bbd5bbf36", size = 7670694, upload-time = "2025-07-03T13:10:56.432Z" }, + { url = "https://files.pythonhosted.org/packages/70/ff/4727d3b71a8578b4587d9c276e90efad2d6fe0335fd76742a6da08132e8c/pillow-11.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c96f993ab8c98460cd0c001447bff6194403e8b1d7e149ade5f00594918128b", size = 6005888, upload-time = "2025-07-01T09:15:39.436Z" }, + { url = "https://files.pythonhosted.org/packages/05/ae/716592277934f85d3be51d7256f3636672d7b1abfafdc42cf3f8cbd4b4c8/pillow-11.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:41342b64afeba938edb034d122b2dda5db2139b9a4af999729ba8818e0056477", size = 6670330, upload-time = "2025-07-01T09:15:41.269Z" }, + { url = "https://files.pythonhosted.org/packages/e7/bb/7fe6cddcc8827b01b1a9766f5fdeb7418680744f9082035bdbabecf1d57f/pillow-11.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:068d9c39a2d1b358eb9f245ce7ab1b5c3246c7c8c7d9ba58cfa5b43146c06e50", size = 6114089, upload-time = "2025-07-01T09:15:43.13Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f5/06bfaa444c8e80f1a8e4bff98da9c83b37b5be3b1deaa43d27a0db37ef84/pillow-11.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a1bc6ba083b145187f648b667e05a2534ecc4b9f2784c2cbe3089e44868f2b9b", size = 6748206, upload-time = "2025-07-01T09:15:44.937Z" }, + { url = "https://files.pythonhosted.org/packages/f0/77/bc6f92a3e8e6e46c0ca78abfffec0037845800ea38c73483760362804c41/pillow-11.3.0-cp314-cp314t-win32.whl", hash = "sha256:118ca10c0d60b06d006be10a501fd6bbdfef559251ed31b794668ed569c87e12", size = 6377370, upload-time = "2025-07-01T09:15:46.673Z" }, + { url = "https://files.pythonhosted.org/packages/4a/82/3a721f7d69dca802befb8af08b7c79ebcab461007ce1c18bd91a5d5896f9/pillow-11.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8924748b688aa210d79883357d102cd64690e56b923a186f35a82cbc10f997db", size = 7121500, upload-time = "2025-07-01T09:15:48.512Z" }, + { url = "https://files.pythonhosted.org/packages/89/c7/5572fa4a3f45740eaab6ae86fcdf7195b55beac1371ac8c619d880cfe948/pillow-11.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:79ea0d14d3ebad43ec77ad5272e6ff9bba5b679ef73375ea760261207fa8e0aa", size = 2512835, upload-time = "2025-07-01T09:15:50.399Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/23/e8/21db9c9987b0e728855bd57bff6984f67952bea55d6f75e055c46b5383e8/platformdirs-4.4.0.tar.gz", hash = "sha256:ca753cf4d81dc309bc67b0ea38fd15dc97bc30ce419a7f58d13eb3bf14c4febf", size = 21634, upload-time = "2025-08-26T14:32:04.268Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/4b/2028861e724d3bd36227adfa20d3fd24c3fc6d52032f4a93c133be5d17ce/platformdirs-4.4.0-py3-none-any.whl", hash = "sha256:abd01743f24e5287cd7a5db3752faf1a2d65353f38ec26d98e25a6db65958c85", size = 18654, upload-time = "2025-08-26T14:32:02.735Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + +[[package]] +name = "psutil" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003, upload-time = "2025-02-13T21:54:07.946Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051, upload-time = "2025-02-13T21:54:12.36Z" }, + { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535, upload-time = "2025-02-13T21:54:16.07Z" }, + { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004, upload-time = "2025-02-13T21:54:18.662Z" }, + { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986, upload-time = "2025-02-13T21:54:21.811Z" }, + { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544, upload-time = "2025-02-13T21:54:24.68Z" }, + { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053, upload-time = "2025-02-13T21:54:34.31Z" }, + { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885, upload-time = "2025-02-13T21:54:37.486Z" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "pycodestyle" +version = "2.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/11/e0/abfd2a0d2efe47670df87f3e3a0e2edda42f055053c85361f19c0e2c1ca8/pycodestyle-2.14.0.tar.gz", hash = "sha256:c4b5b517d278089ff9d0abdec919cd97262a3367449ea1c8b49b91529167b783", size = 39472, upload-time = "2025-06-20T18:49:48.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/27/a58ddaf8c588a3ef080db9d0b7e0b97215cee3a45df74f3a94dbbf5c893a/pycodestyle-2.14.0-py2.py3-none-any.whl", hash = "sha256:dd6bf7cb4ee77f8e016f9c8e74a35ddd9f67e1d5fd4184d86c3b98e07099f42d", size = 31594, upload-time = "2025-06-20T18:49:47.491Z" }, +] + +[[package]] +name = "pycparser" +version = "2.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/cf/d2d3b9f5699fb1e4615c8e32ff220203e43b248e1dfcc6736ad9057731ca/pycparser-2.23.tar.gz", hash = "sha256:78816d4f24add8f10a06d6f05b4d424ad9e96cfebf68a4ddc99c65c0720d00c2", size = 173734, upload-time = "2025-09-09T13:23:47.91Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/e3/59cd50310fc9b59512193629e1984c1f95e5c8ae6e5d8c69532ccc65a7fe/pycparser-2.23-py3-none-any.whl", hash = "sha256:e5c6e8d3fbad53479cab09ac03729e0a9faf2bee3db8208a550daf5af81a5934", size = 118140, upload-time = "2025-09-09T13:23:46.651Z" }, +] + +[[package]] +name = "pydantic" +version = "2.11.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/00/dd/4325abf92c39ba8623b5af936ddb36ffcfe0beae70405d456ab1fb2f5b8c/pydantic-2.11.7.tar.gz", hash = "sha256:d989c3c6cb79469287b1569f7447a17848c998458d49ebe294e975b9baf0f0db", size = 788350, upload-time = "2025-06-14T08:33:17.137Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/c0/ec2b1c8712ca690e5d61979dee872603e92b8a32f94cc1b72d53beab008a/pydantic-2.11.7-py3-none-any.whl", hash = "sha256:dde5df002701f6de26248661f6835bbe296a47bf73990135c7d07ce741b9623b", size = 444782, upload-time = "2025-06-14T08:33:14.905Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.33.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload-time = "2025-04-23T18:31:25.863Z" }, + { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload-time = "2025-04-23T18:31:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload-time = "2025-04-23T18:31:28.956Z" }, + { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload-time = "2025-04-23T18:31:31.025Z" }, + { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload-time = "2025-04-23T18:31:32.514Z" }, + { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload-time = "2025-04-23T18:31:33.958Z" }, + { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload-time = "2025-04-23T18:31:39.095Z" }, + { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload-time = "2025-04-23T18:31:41.034Z" }, + { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload-time = "2025-04-23T18:31:42.757Z" }, + { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload-time = "2025-04-23T18:31:44.304Z" }, + { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload-time = "2025-04-23T18:31:45.891Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload-time = "2025-04-23T18:31:47.819Z" }, + { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload-time = "2025-04-23T18:31:49.635Z" }, + { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload-time = "2025-04-23T18:31:51.609Z" }, + { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688, upload-time = "2025-04-23T18:31:53.175Z" }, + { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808, upload-time = "2025-04-23T18:31:54.79Z" }, + { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580, upload-time = "2025-04-23T18:31:57.393Z" }, + { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859, upload-time = "2025-04-23T18:31:59.065Z" }, + { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810, upload-time = "2025-04-23T18:32:00.78Z" }, + { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498, upload-time = "2025-04-23T18:32:02.418Z" }, + { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611, upload-time = "2025-04-23T18:32:04.152Z" }, + { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924, upload-time = "2025-04-23T18:32:06.129Z" }, + { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196, upload-time = "2025-04-23T18:32:08.178Z" }, + { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389, upload-time = "2025-04-23T18:32:10.242Z" }, + { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223, upload-time = "2025-04-23T18:32:12.382Z" }, + { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473, upload-time = "2025-04-23T18:32:14.034Z" }, + { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269, upload-time = "2025-04-23T18:32:15.783Z" }, + { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921, upload-time = "2025-04-23T18:32:18.473Z" }, + { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162, upload-time = "2025-04-23T18:32:20.188Z" }, + { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560, upload-time = "2025-04-23T18:32:22.354Z" }, + { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload-time = "2025-04-23T18:32:25.088Z" }, +] + +[[package]] +name = "pydantic-settings" +version = "2.10.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/68/85/1ea668bbab3c50071ca613c6ab30047fb36ab0da1b92fa8f17bbc38fd36c/pydantic_settings-2.10.1.tar.gz", hash = "sha256:06f0062169818d0f5524420a360d632d5857b83cffd4d42fe29597807a1614ee", size = 172583, upload-time = "2025-06-24T13:26:46.841Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/f0/427018098906416f580e3cf1366d3b1abfb408a0652e9f31600c24a1903c/pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796", size = 45235, upload-time = "2025-06-24T13:26:45.485Z" }, +] + +[[package]] +name = "pyflakes" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/45/dc/fd034dc20b4b264b3d015808458391acbf9df40b1e54750ef175d39180b1/pyflakes-3.4.0.tar.gz", hash = "sha256:b24f96fafb7d2ab0ec5075b7350b3d2d2218eab42003821c06344973d3ea2f58", size = 64669, upload-time = "2025-06-20T18:45:27.834Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/2f/81d580a0fb83baeb066698975cb14a618bdbed7720678566f1b046a95fe8/pyflakes-3.4.0-py2.py3-none-any.whl", hash = "sha256:f742a7dbd0d9cb9ea41e9a24a918996e8170c799fa528688d40dd582c8265f4f", size = 63551, upload-time = "2025-06-20T18:45:26.937Z" }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, +] + +[[package]] +name = "pyjwt" +version = "2.10.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/46/bd74733ff231675599650d3e47f361794b22ef3e3770998dda30d3b63726/pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953", size = 87785, upload-time = "2024-11-28T03:43:29.933Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/ad/689f02752eeec26aed679477e80e632ef1b682313be70793d798c1d5fc8f/PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb", size = 22997, upload-time = "2024-11-28T03:43:27.893Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bb/22/f1129e69d94ffff626bdb5c835506b3a5b4f3d070f17ea295e12c2c6f60f/pyparsing-3.2.3.tar.gz", hash = "sha256:b9c13f1ab8b3b542f72e28f634bad4de758ab3ce4546e4301970ad6fa77c38be", size = 1088608, upload-time = "2025-03-25T05:01:28.114Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/e7/df2285f3d08fee213f2d041540fa4fc9ca6c2d44cf36d3a035bf2a8d2bcc/pyparsing-3.2.3-py3-none-any.whl", hash = "sha256:a749938e02d6fd0b59b356ca504a24982314bb090c383e3cf201c95ef7e2bfcf", size = 111120, upload-time = "2025-03-25T05:01:24.908Z" }, +] + +[[package]] +name = "pytest" +version = "8.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "python-dotenv" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/b0/4bc07ccd3572a2f9df7e6782f52b0c6c90dcbb803ac4a167702d7d0dfe1e/python_dotenv-1.1.1.tar.gz", hash = "sha256:a8a6399716257f45be6a007360200409fce5cda2661e3dec71d23dc15f6189ab", size = 41978, upload-time = "2025-06-24T04:21:07.341Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" }, +] + +[[package]] +name = "pytz" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" }, +] + +[[package]] +name = "pywin32" +version = "311" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/ab/01ea1943d4eba0f850c3c61e78e8dd59757ff815ff3ccd0a84de5f541f42/pywin32-311-cp312-cp312-win32.whl", hash = "sha256:750ec6e621af2b948540032557b10a2d43b0cee2ae9758c54154d711cc852d31", size = 8706543, upload-time = "2025-07-14T20:13:20.765Z" }, + { url = "https://files.pythonhosted.org/packages/d1/a8/a0e8d07d4d051ec7502cd58b291ec98dcc0c3fff027caad0470b72cfcc2f/pywin32-311-cp312-cp312-win_amd64.whl", hash = "sha256:b8c095edad5c211ff31c05223658e71bf7116daa0ecf3ad85f3201ea3190d067", size = 9495040, upload-time = "2025-07-14T20:13:22.543Z" }, + { url = "https://files.pythonhosted.org/packages/ba/3a/2ae996277b4b50f17d61f0603efd8253cb2d79cc7ae159468007b586396d/pywin32-311-cp312-cp312-win_arm64.whl", hash = "sha256:e286f46a9a39c4a18b319c28f59b61de793654af2f395c102b4f819e584b5852", size = 8710102, upload-time = "2025-07-14T20:13:24.682Z" }, + { url = "https://files.pythonhosted.org/packages/a5/be/3fd5de0979fcb3994bfee0d65ed8ca9506a8a1260651b86174f6a86f52b3/pywin32-311-cp313-cp313-win32.whl", hash = "sha256:f95ba5a847cba10dd8c4d8fefa9f2a6cf283b8b88ed6178fa8a6c1ab16054d0d", size = 8705700, upload-time = "2025-07-14T20:13:26.471Z" }, + { url = "https://files.pythonhosted.org/packages/e3/28/e0a1909523c6890208295a29e05c2adb2126364e289826c0a8bc7297bd5c/pywin32-311-cp313-cp313-win_amd64.whl", hash = "sha256:718a38f7e5b058e76aee1c56ddd06908116d35147e133427e59a3983f703a20d", size = 9494700, upload-time = "2025-07-14T20:13:28.243Z" }, + { url = "https://files.pythonhosted.org/packages/04/bf/90339ac0f55726dce7d794e6d79a18a91265bdf3aa70b6b9ca52f35e022a/pywin32-311-cp313-cp313-win_arm64.whl", hash = "sha256:7b4075d959648406202d92a2310cb990fea19b535c7f4a78d3f5e10b926eeb8a", size = 8709318, upload-time = "2025-07-14T20:13:30.348Z" }, + { url = "https://files.pythonhosted.org/packages/c9/31/097f2e132c4f16d99a22bfb777e0fd88bd8e1c634304e102f313af69ace5/pywin32-311-cp314-cp314-win32.whl", hash = "sha256:b7a2c10b93f8986666d0c803ee19b5990885872a7de910fc460f9b0c2fbf92ee", size = 8840714, upload-time = "2025-07-14T20:13:32.449Z" }, + { url = "https://files.pythonhosted.org/packages/90/4b/07c77d8ba0e01349358082713400435347df8426208171ce297da32c313d/pywin32-311-cp314-cp314-win_amd64.whl", hash = "sha256:3aca44c046bd2ed8c90de9cb8427f581c479e594e99b5c0bb19b29c10fd6cb87", size = 9656800, upload-time = "2025-07-14T20:13:34.312Z" }, + { url = "https://files.pythonhosted.org/packages/c0/d2/21af5c535501a7233e734b8af901574572da66fcc254cb35d0609c9080dd/pywin32-311-cp314-cp314-win_arm64.whl", hash = "sha256:a508e2d9025764a8270f93111a970e1d0fbfc33f4153b388bb649b7eec4f9b42", size = 8932540, upload-time = "2025-07-14T20:13:36.379Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631, upload-time = "2024-08-06T20:33:50.674Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873, upload-time = "2024-08-06T20:32:25.131Z" }, + { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302, upload-time = "2024-08-06T20:32:26.511Z" }, + { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154, upload-time = "2024-08-06T20:32:28.363Z" }, + { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223, upload-time = "2024-08-06T20:32:30.058Z" }, + { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542, upload-time = "2024-08-06T20:32:31.881Z" }, + { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164, upload-time = "2024-08-06T20:32:37.083Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611, upload-time = "2024-08-06T20:32:38.898Z" }, + { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591, upload-time = "2024-08-06T20:32:40.241Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338, upload-time = "2024-08-06T20:32:41.93Z" }, + { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309, upload-time = "2024-08-06T20:32:43.4Z" }, + { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679, upload-time = "2024-08-06T20:32:44.801Z" }, + { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428, upload-time = "2024-08-06T20:32:46.432Z" }, + { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361, upload-time = "2024-08-06T20:32:51.188Z" }, + { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523, upload-time = "2024-08-06T20:32:53.019Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660, upload-time = "2024-08-06T20:32:54.708Z" }, + { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597, upload-time = "2024-08-06T20:32:56.985Z" }, + { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527, upload-time = "2024-08-06T20:33:03.001Z" }, + { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446, upload-time = "2024-08-06T20:33:04.33Z" }, +] + +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, +] + +[[package]] +name = "radon" +version = "6.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama" }, + { name = "mando" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/6d/98e61600febf6bd929cf04154537c39dc577ce414bafbfc24a286c4fa76d/radon-6.0.1.tar.gz", hash = "sha256:d1ac0053943a893878940fedc8b19ace70386fc9c9bf0a09229a44125ebf45b5", size = 1874992, upload-time = "2023-03-26T06:24:38.868Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/f7/d00d9b4a0313a6be3a3e0818e6375e15da6d7076f4ae47d1324e7ca986a1/radon-6.0.1-py2.py3-none-any.whl", hash = "sha256:632cc032364a6f8bb1010a2f6a12d0f14bc7e5ede76585ef29dc0cecf4cd8859", size = 52784, upload-time = "2023-03-26T06:24:33.949Z" }, +] + +[[package]] +name = "rich" +version = "14.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fe/75/af448d8e52bf1d8fa6a9d089ca6c07ff4453d86c65c145d0a300bb073b9b/rich-14.1.0.tar.gz", hash = "sha256:e497a48b844b0320d45007cdebfeaeed8db2a4f4bcf49f15e455cfc4af11eaa8", size = 224441, upload-time = "2025-07-25T07:32:58.125Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/30/3c4d035596d3cf444529e0b2953ad0466f6049528a879d27534700580395/rich-14.1.0-py3-none-any.whl", hash = "sha256:536f5f1785986d6dbdea3c75205c473f970777b4a0d6c6dd1b696aa05a3fa04f", size = 243368, upload-time = "2025-07-25T07:32:56.73Z" }, +] + +[[package]] +name = "ruff" +version = "0.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6e/1a/1f4b722862840295bcaba8c9e5261572347509548faaa99b2d57ee7bfe6a/ruff-0.13.0.tar.gz", hash = "sha256:5b4b1ee7eb35afae128ab94459b13b2baaed282b1fb0f472a73c82c996c8ae60", size = 5372863, upload-time = "2025-09-10T16:25:37.917Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ac/fe/6f87b419dbe166fd30a991390221f14c5b68946f389ea07913e1719741e0/ruff-0.13.0-py3-none-linux_armv6l.whl", hash = "sha256:137f3d65d58ee828ae136a12d1dc33d992773d8f7644bc6b82714570f31b2004", size = 12187826, upload-time = "2025-09-10T16:24:39.5Z" }, + { url = "https://files.pythonhosted.org/packages/e4/25/c92296b1fc36d2499e12b74a3fdb230f77af7bdf048fad7b0a62e94ed56a/ruff-0.13.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:21ae48151b66e71fd111b7d79f9ad358814ed58c339631450c66a4be33cc28b9", size = 12933428, upload-time = "2025-09-10T16:24:43.866Z" }, + { url = "https://files.pythonhosted.org/packages/44/cf/40bc7221a949470307d9c35b4ef5810c294e6cfa3caafb57d882731a9f42/ruff-0.13.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:64de45f4ca5441209e41742d527944635a05a6e7c05798904f39c85bafa819e3", size = 12095543, upload-time = "2025-09-10T16:24:46.638Z" }, + { url = "https://files.pythonhosted.org/packages/f1/03/8b5ff2a211efb68c63a1d03d157e924997ada87d01bebffbd13a0f3fcdeb/ruff-0.13.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2b2c653ae9b9d46e0ef62fc6fbf5b979bda20a0b1d2b22f8f7eb0cde9f4963b8", size = 12312489, upload-time = "2025-09-10T16:24:49.556Z" }, + { url = "https://files.pythonhosted.org/packages/37/fc/2336ef6d5e9c8d8ea8305c5f91e767d795cd4fc171a6d97ef38a5302dadc/ruff-0.13.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4cec632534332062bc9eb5884a267b689085a1afea9801bf94e3ba7498a2d207", size = 11991631, upload-time = "2025-09-10T16:24:53.439Z" }, + { url = "https://files.pythonhosted.org/packages/39/7f/f6d574d100fca83d32637d7f5541bea2f5e473c40020bbc7fc4a4d5b7294/ruff-0.13.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dcd628101d9f7d122e120ac7c17e0a0f468b19bc925501dbe03c1cb7f5415b24", size = 13720602, upload-time = "2025-09-10T16:24:56.392Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c8/a8a5b81d8729b5d1f663348d11e2a9d65a7a9bd3c399763b1a51c72be1ce/ruff-0.13.0-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:afe37db8e1466acb173bb2a39ca92df00570e0fd7c94c72d87b51b21bb63efea", size = 14697751, upload-time = "2025-09-10T16:24:59.89Z" }, + { url = "https://files.pythonhosted.org/packages/57/f5/183ec292272ce7ec5e882aea74937f7288e88ecb500198b832c24debc6d3/ruff-0.13.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0f96a8d90bb258d7d3358b372905fe7333aaacf6c39e2408b9f8ba181f4b6ef2", size = 14095317, upload-time = "2025-09-10T16:25:03.025Z" }, + { url = "https://files.pythonhosted.org/packages/9f/8d/7f9771c971724701af7926c14dab31754e7b303d127b0d3f01116faef456/ruff-0.13.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94b5e3d883e4f924c5298e3f2ee0f3085819c14f68d1e5b6715597681433f153", size = 13144418, upload-time = "2025-09-10T16:25:06.272Z" }, + { url = "https://files.pythonhosted.org/packages/a8/a6/7985ad1778e60922d4bef546688cd8a25822c58873e9ff30189cfe5dc4ab/ruff-0.13.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03447f3d18479df3d24917a92d768a89f873a7181a064858ea90a804a7538991", size = 13370843, upload-time = "2025-09-10T16:25:09.965Z" }, + { url = "https://files.pythonhosted.org/packages/64/1c/bafdd5a7a05a50cc51d9f5711da704942d8dd62df3d8c70c311e98ce9f8a/ruff-0.13.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:fbc6b1934eb1c0033da427c805e27d164bb713f8e273a024a7e86176d7f462cf", size = 13321891, upload-time = "2025-09-10T16:25:12.969Z" }, + { url = "https://files.pythonhosted.org/packages/bc/3e/7817f989cb9725ef7e8d2cee74186bf90555279e119de50c750c4b7a72fe/ruff-0.13.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a8ab6a3e03665d39d4a25ee199d207a488724f022db0e1fe4002968abdb8001b", size = 12119119, upload-time = "2025-09-10T16:25:16.621Z" }, + { url = "https://files.pythonhosted.org/packages/58/07/9df080742e8d1080e60c426dce6e96a8faf9a371e2ce22eef662e3839c95/ruff-0.13.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d2a5c62f8ccc6dd2fe259917482de7275cecc86141ee10432727c4816235bc41", size = 11961594, upload-time = "2025-09-10T16:25:19.49Z" }, + { url = "https://files.pythonhosted.org/packages/6a/f4/ae1185349197d26a2316840cb4d6c3fba61d4ac36ed728bf0228b222d71f/ruff-0.13.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:b7b85ca27aeeb1ab421bc787009831cffe6048faae08ad80867edab9f2760945", size = 12933377, upload-time = "2025-09-10T16:25:22.371Z" }, + { url = "https://files.pythonhosted.org/packages/b6/39/e776c10a3b349fc8209a905bfb327831d7516f6058339a613a8d2aaecacd/ruff-0.13.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:79ea0c44a3032af768cabfd9616e44c24303af49d633b43e3a5096e009ebe823", size = 13418555, upload-time = "2025-09-10T16:25:25.681Z" }, + { url = "https://files.pythonhosted.org/packages/46/09/dca8df3d48e8b3f4202bf20b1658898e74b6442ac835bfe2c1816d926697/ruff-0.13.0-py3-none-win32.whl", hash = "sha256:4e473e8f0e6a04e4113f2e1de12a5039579892329ecc49958424e5568ef4f768", size = 12141613, upload-time = "2025-09-10T16:25:28.664Z" }, + { url = "https://files.pythonhosted.org/packages/61/21/0647eb71ed99b888ad50e44d8ec65d7148babc0e242d531a499a0bbcda5f/ruff-0.13.0-py3-none-win_amd64.whl", hash = "sha256:48e5c25c7a3713eea9ce755995767f4dcd1b0b9599b638b12946e892123d1efb", size = 13258250, upload-time = "2025-09-10T16:25:31.773Z" }, + { url = "https://files.pythonhosted.org/packages/e1/a3/03216a6a86c706df54422612981fb0f9041dbb452c3401501d4a22b942c9/ruff-0.13.0-py3-none-win_arm64.whl", hash = "sha256:ab80525317b1e1d38614addec8ac954f1b3e662de9d59114ecbf771d00cf613e", size = 12312357, upload-time = "2025-09-10T16:25:35.595Z" }, +] + +[[package]] +name = "seaborn" +version = "0.13.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, + { name = "numpy" }, + { name = "pandas" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696, upload-time = "2024-01-25T13:21:52.551Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/11/00d3c3dfc25ad54e731d91449895a79e4bf2384dc3ac01809010ba88f6d5/seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987", size = 294914, upload-time = "2024-01-25T13:21:49.598Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "sniffio" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, +] + +[[package]] +name = "sqlalchemy" +version = "2.0.43" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "greenlet", marker = "(python_full_version < '3.14' and platform_machine == 'AMD64') or (python_full_version < '3.14' and platform_machine == 'WIN32') or (python_full_version < '3.14' and platform_machine == 'aarch64') or (python_full_version < '3.14' and platform_machine == 'amd64') or (python_full_version < '3.14' and platform_machine == 'ppc64le') or (python_full_version < '3.14' and platform_machine == 'win32') or (python_full_version < '3.14' and platform_machine == 'x86_64')" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d7/bc/d59b5d97d27229b0e009bd9098cd81af71c2fa5549c580a0a67b9bed0496/sqlalchemy-2.0.43.tar.gz", hash = "sha256:788bfcef6787a7764169cfe9859fe425bf44559619e1d9f56f5bddf2ebf6f417", size = 9762949, upload-time = "2025-08-11T14:24:58.438Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/61/db/20c78f1081446095450bdc6ee6cc10045fce67a8e003a5876b6eaafc5cc4/sqlalchemy-2.0.43-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:20d81fc2736509d7a2bd33292e489b056cbae543661bb7de7ce9f1c0cd6e7f24", size = 2134891, upload-time = "2025-08-11T15:51:13.019Z" }, + { url = "https://files.pythonhosted.org/packages/45/0a/3d89034ae62b200b4396f0f95319f7d86e9945ee64d2343dcad857150fa2/sqlalchemy-2.0.43-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:25b9fc27650ff5a2c9d490c13c14906b918b0de1f8fcbb4c992712d8caf40e83", size = 2123061, upload-time = "2025-08-11T15:51:14.319Z" }, + { url = "https://files.pythonhosted.org/packages/cb/10/2711f7ff1805919221ad5bee205971254845c069ee2e7036847103ca1e4c/sqlalchemy-2.0.43-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6772e3ca8a43a65a37c88e2f3e2adfd511b0b1da37ef11ed78dea16aeae85bd9", size = 3320384, upload-time = "2025-08-11T15:52:35.088Z" }, + { url = "https://files.pythonhosted.org/packages/6e/0e/3d155e264d2ed2778484006ef04647bc63f55b3e2d12e6a4f787747b5900/sqlalchemy-2.0.43-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a113da919c25f7f641ffbd07fbc9077abd4b3b75097c888ab818f962707eb48", size = 3329648, upload-time = "2025-08-11T15:56:34.153Z" }, + { url = "https://files.pythonhosted.org/packages/5b/81/635100fb19725c931622c673900da5efb1595c96ff5b441e07e3dd61f2be/sqlalchemy-2.0.43-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4286a1139f14b7d70141c67a8ae1582fc2b69105f1b09d9573494eb4bb4b2687", size = 3258030, upload-time = "2025-08-11T15:52:36.933Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ed/a99302716d62b4965fded12520c1cbb189f99b17a6d8cf77611d21442e47/sqlalchemy-2.0.43-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:529064085be2f4d8a6e5fab12d36ad44f1909a18848fcfbdb59cc6d4bbe48efe", size = 3294469, upload-time = "2025-08-11T15:56:35.553Z" }, + { url = "https://files.pythonhosted.org/packages/5d/a2/3a11b06715149bf3310b55a98b5c1e84a42cfb949a7b800bc75cb4e33abc/sqlalchemy-2.0.43-cp312-cp312-win32.whl", hash = "sha256:b535d35dea8bbb8195e7e2b40059e2253acb2b7579b73c1b432a35363694641d", size = 2098906, upload-time = "2025-08-11T15:55:00.645Z" }, + { url = "https://files.pythonhosted.org/packages/bc/09/405c915a974814b90aa591280623adc6ad6b322f61fd5cff80aeaef216c9/sqlalchemy-2.0.43-cp312-cp312-win_amd64.whl", hash = "sha256:1c6d85327ca688dbae7e2b06d7d84cfe4f3fffa5b5f9e21bb6ce9d0e1a0e0e0a", size = 2126260, upload-time = "2025-08-11T15:55:02.965Z" }, + { url = "https://files.pythonhosted.org/packages/41/1c/a7260bd47a6fae7e03768bf66451437b36451143f36b285522b865987ced/sqlalchemy-2.0.43-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e7c08f57f75a2bb62d7ee80a89686a5e5669f199235c6d1dac75cd59374091c3", size = 2130598, upload-time = "2025-08-11T15:51:15.903Z" }, + { url = "https://files.pythonhosted.org/packages/8e/84/8a337454e82388283830b3586ad7847aa9c76fdd4f1df09cdd1f94591873/sqlalchemy-2.0.43-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:14111d22c29efad445cd5021a70a8b42f7d9152d8ba7f73304c4d82460946aaa", size = 2118415, upload-time = "2025-08-11T15:51:17.256Z" }, + { url = "https://files.pythonhosted.org/packages/cf/ff/22ab2328148492c4d71899d62a0e65370ea66c877aea017a244a35733685/sqlalchemy-2.0.43-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21b27b56eb2f82653168cefe6cb8e970cdaf4f3a6cb2c5e3c3c1cf3158968ff9", size = 3248707, upload-time = "2025-08-11T15:52:38.444Z" }, + { url = "https://files.pythonhosted.org/packages/dc/29/11ae2c2b981de60187f7cbc84277d9d21f101093d1b2e945c63774477aba/sqlalchemy-2.0.43-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c5a9da957c56e43d72126a3f5845603da00e0293720b03bde0aacffcf2dc04f", size = 3253602, upload-time = "2025-08-11T15:56:37.348Z" }, + { url = "https://files.pythonhosted.org/packages/b8/61/987b6c23b12c56d2be451bc70900f67dd7d989d52b1ee64f239cf19aec69/sqlalchemy-2.0.43-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d79f9fdc9584ec83d1b3c75e9f4595c49017f5594fee1a2217117647225d738", size = 3183248, upload-time = "2025-08-11T15:52:39.865Z" }, + { url = "https://files.pythonhosted.org/packages/86/85/29d216002d4593c2ce1c0ec2cec46dda77bfbcd221e24caa6e85eff53d89/sqlalchemy-2.0.43-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9df7126fd9db49e3a5a3999442cc67e9ee8971f3cb9644250107d7296cb2a164", size = 3219363, upload-time = "2025-08-11T15:56:39.11Z" }, + { url = "https://files.pythonhosted.org/packages/b6/e4/bd78b01919c524f190b4905d47e7630bf4130b9f48fd971ae1c6225b6f6a/sqlalchemy-2.0.43-cp313-cp313-win32.whl", hash = "sha256:7f1ac7828857fcedb0361b48b9ac4821469f7694089d15550bbcf9ab22564a1d", size = 2096718, upload-time = "2025-08-11T15:55:05.349Z" }, + { url = "https://files.pythonhosted.org/packages/ac/a5/ca2f07a2a201f9497de1928f787926613db6307992fe5cda97624eb07c2f/sqlalchemy-2.0.43-cp313-cp313-win_amd64.whl", hash = "sha256:971ba928fcde01869361f504fcff3b7143b47d30de188b11c6357c0505824197", size = 2123200, upload-time = "2025-08-11T15:55:07.932Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d9/13bdde6521f322861fab67473cec4b1cc8999f3871953531cf61945fad92/sqlalchemy-2.0.43-py3-none-any.whl", hash = "sha256:1681c21dd2ccee222c2fe0bef671d1aef7c504087c9c4e800371cfcc8ac966fc", size = 1924759, upload-time = "2025-08-11T15:39:53.024Z" }, +] + +[[package]] +name = "sqlmodel" +version = "0.0.24" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pydantic" }, + { name = "sqlalchemy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/4b/c2ad0496f5bdc6073d9b4cef52be9c04f2b37a5773441cc6600b1857648b/sqlmodel-0.0.24.tar.gz", hash = "sha256:cc5c7613c1a5533c9c7867e1aab2fd489a76c9e8a061984da11b4e613c182423", size = 116780, upload-time = "2025-03-07T05:43:32.887Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/16/91/484cd2d05569892b7fef7f5ceab3bc89fb0f8a8c0cde1030d383dbc5449c/sqlmodel-0.0.24-py3-none-any.whl", hash = "sha256:6778852f09370908985b667d6a3ab92910d0d5ec88adcaf23dbc242715ff7193", size = 28622, upload-time = "2025-03-07T05:43:30.37Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + +[[package]] +name = "starlette" +version = "0.47.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/15/b9/cc3017f9a9c9b6e27c5106cc10cc7904653c3eec0729793aec10479dd669/starlette-0.47.3.tar.gz", hash = "sha256:6bc94f839cc176c4858894f1f8908f0ab79dfec1a6b8402f6da9be26ebea52e9", size = 2584144, upload-time = "2025-08-24T13:36:42.122Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/fd/901cfa59aaa5b30a99e16876f11abe38b59a1a2c51ffb3d7142bb6089069/starlette-0.47.3-py3-none-any.whl", hash = "sha256:89c0778ca62a76b826101e7c709e70680a1699ca7da6b44d38eb0a7e61fe4b51", size = 72991, upload-time = "2025-08-24T13:36:40.887Z" }, +] + +[[package]] +name = "stevedore" +version = "5.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/5f/8418daad5c353300b7661dd8ce2574b0410a6316a8be650a189d5c68d938/stevedore-5.5.0.tar.gz", hash = "sha256:d31496a4f4df9825e1a1e4f1f74d19abb0154aff311c3b376fcc89dae8fccd73", size = 513878, upload-time = "2025-08-25T12:54:26.806Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/80/c5/0c06759b95747882bb50abda18f5fb48c3e9b0fbfc6ebc0e23550b52415d/stevedore-5.5.0-py3-none-any.whl", hash = "sha256:18363d4d268181e8e8452e71a38cd77630f345b2ef6b4a8d5614dac5ee0d18cf", size = 49518, upload-time = "2025-08-25T12:54:25.445Z" }, +] + +[[package]] +name = "tenacity" +version = "9.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0a/d4/2b0cd0fe285e14b36db076e78c93766ff1d529d70408bd1d2a5a84f1d929/tenacity-9.1.2.tar.gz", hash = "sha256:1169d376c297e7de388d18b4481760d478b0e99a777cad3a9c86e556f4b697cb", size = 48036, upload-time = "2025-04-02T08:25:09.966Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/30/643397144bfbfec6f6ef821f36f33e57d35946c44a2352d3c9f0ae847619/tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138", size = 28248, upload-time = "2025-04-02T08:25:07.678Z" }, +] + +[[package]] +name = "tornado" +version = "6.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/09/ce/1eb500eae19f4648281bb2186927bb062d2438c2e5093d1360391afd2f90/tornado-6.5.2.tar.gz", hash = "sha256:ab53c8f9a0fa351e2c0741284e06c7a45da86afb544133201c5cc8578eb076a0", size = 510821, upload-time = "2025-08-08T18:27:00.78Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/48/6a7529df2c9cc12efd2e8f5dd219516184d703b34c06786809670df5b3bd/tornado-6.5.2-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2436822940d37cde62771cff8774f4f00b3c8024fe482e16ca8387b8a2724db6", size = 442563, upload-time = "2025-08-08T18:26:42.945Z" }, + { url = "https://files.pythonhosted.org/packages/f2/b5/9b575a0ed3e50b00c40b08cbce82eb618229091d09f6d14bce80fc01cb0b/tornado-6.5.2-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:583a52c7aa94ee046854ba81d9ebb6c81ec0fd30386d96f7640c96dad45a03ef", size = 440729, upload-time = "2025-08-08T18:26:44.473Z" }, + { url = "https://files.pythonhosted.org/packages/1b/4e/619174f52b120efcf23633c817fd3fed867c30bff785e2cd5a53a70e483c/tornado-6.5.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0fe179f28d597deab2842b86ed4060deec7388f1fd9c1b4a41adf8af058907e", size = 444295, upload-time = "2025-08-08T18:26:46.021Z" }, + { url = "https://files.pythonhosted.org/packages/95/fa/87b41709552bbd393c85dd18e4e3499dcd8983f66e7972926db8d96aa065/tornado-6.5.2-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b186e85d1e3536d69583d2298423744740986018e393d0321df7340e71898882", size = 443644, upload-time = "2025-08-08T18:26:47.625Z" }, + { url = "https://files.pythonhosted.org/packages/f9/41/fb15f06e33d7430ca89420283a8762a4e6b8025b800ea51796ab5e6d9559/tornado-6.5.2-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e792706668c87709709c18b353da1f7662317b563ff69f00bab83595940c7108", size = 443878, upload-time = "2025-08-08T18:26:50.599Z" }, + { url = "https://files.pythonhosted.org/packages/11/92/fe6d57da897776ad2e01e279170ea8ae726755b045fe5ac73b75357a5a3f/tornado-6.5.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:06ceb1300fd70cb20e43b1ad8aaee0266e69e7ced38fa910ad2e03285009ce7c", size = 444549, upload-time = "2025-08-08T18:26:51.864Z" }, + { url = "https://files.pythonhosted.org/packages/9b/02/c8f4f6c9204526daf3d760f4aa555a7a33ad0e60843eac025ccfd6ff4a93/tornado-6.5.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:74db443e0f5251be86cbf37929f84d8c20c27a355dd452a5cfa2aada0d001ec4", size = 443973, upload-time = "2025-08-08T18:26:53.625Z" }, + { url = "https://files.pythonhosted.org/packages/ae/2d/f5f5707b655ce2317190183868cd0f6822a1121b4baeae509ceb9590d0bd/tornado-6.5.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b5e735ab2889d7ed33b32a459cac490eda71a1ba6857b0118de476ab6c366c04", size = 443954, upload-time = "2025-08-08T18:26:55.072Z" }, + { url = "https://files.pythonhosted.org/packages/e8/59/593bd0f40f7355806bf6573b47b8c22f8e1374c9b6fd03114bd6b7a3dcfd/tornado-6.5.2-cp39-abi3-win32.whl", hash = "sha256:c6f29e94d9b37a95013bb669616352ddb82e3bfe8326fccee50583caebc8a5f0", size = 445023, upload-time = "2025-08-08T18:26:56.677Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2a/f609b420c2f564a748a2d80ebfb2ee02a73ca80223af712fca591386cafb/tornado-6.5.2-cp39-abi3-win_amd64.whl", hash = "sha256:e56a5af51cc30dd2cae649429af65ca2f6571da29504a07995175df14c18f35f", size = 445427, upload-time = "2025-08-08T18:26:57.91Z" }, + { url = "https://files.pythonhosted.org/packages/5e/4f/e1f65e8f8c76d73658b33d33b81eed4322fb5085350e4328d5c956f0c8f9/tornado-6.5.2-cp39-abi3-win_arm64.whl", hash = "sha256:d6c33dc3672e3a1f3618eb63b7ef4683a7688e7b9e6e8f0d9aa5726360a004af", size = 444456, upload-time = "2025-08-08T18:26:59.207Z" }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, +] + +[[package]] +name = "types-passlib" +version = "1.7.7.20250602" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fa/3e/501a5832130e5f93450b1e02090e2ee27a37135d11378a47debf960e3131/types_passlib-1.7.7.20250602.tar.gz", hash = "sha256:cf2350e78d36b6b09e4db44284d96651b57285f499cfabf111b616065abab7b3", size = 25406, upload-time = "2025-06-02T03:14:56.033Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/fc/530236c21f1a0be84c42b23c91c250ef96404c475b739ac4479430ebd7d4/types_passlib-1.7.7.20250602-py3-none-any.whl", hash = "sha256:ed73a91be9a22484ebd62cc0d127675ded542b892b99776db92dab760bbfe274", size = 40410, upload-time = "2025-06-02T03:14:54.834Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload-time = "2025-05-21T18:55:23.885Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552, upload-time = "2025-05-21T18:55:22.152Z" }, +] + +[[package]] +name = "tzdata" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301, upload-time = "2024-01-06T02:10:57.829Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166, upload-time = "2024-01-06T02:10:55.763Z" }, +] + +[[package]] +name = "wemake-python-styleguide" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "flake8" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b8/08/c0776aa654dc43cb390e8ee13f597e7241495f30b454b7534ee482ece5b5/wemake_python_styleguide-1.4.0.tar.gz", hash = "sha256:0964cf40ac4d3f1c89dd79aee4b6edba9a1806fb395836c73e746fe287dbae3e", size = 153955, upload-time = "2025-08-25T10:15:08.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/58/98c4aa00e3de8e45726029799d8facbdcd75347b2f48b285857577e8efd8/wemake_python_styleguide-1.4.0-py3-none-any.whl", hash = "sha256:c0727475a20a1b7d59f1d806040e84768bdb0935d1147023453aa44c14b65c95", size = 215985, upload-time = "2025-08-25T10:15:06.713Z" }, +]