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/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py b/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py new file mode 100644 index 0000000000..37383d9287 --- /dev/null +++ b/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py @@ -0,0 +1,66 @@ +"""add_wallet_and_transaction_models + +Revision ID: fd8dcfe8d4fd +Revises: 1a31ce608336 +Create Date: 2025-09-12 22:28:29.785616 + +""" + +import sqlalchemy as sa +from alembic import op + +# revision identifiers, used by Alembic. +revision = "fd8dcfe8d4fd" +down_revision = "1a31ce608336" +branch_labels = None +depends_on = None + + +def upgrade(): + # Create wallet table + op.create_table( + "wallet", + sa.Column("id", sa.UUID(), nullable=False), + sa.Column("user_id", sa.UUID(), nullable=False), + sa.Column( + "currency", + sa.Enum("USD", "EUR", "RUB", name="currencyenum"), + nullable=False, + ), + sa.Column("balance", sa.Numeric(precision=10, scale=2), nullable=False), + sa.ForeignKeyConstraint(["user_id"], ["user.id"], ondelete="CASCADE"), + sa.PrimaryKeyConstraint("id"), + ) + + # Create transaction table + op.create_table( + "transaction", + sa.Column("id", sa.UUID(), nullable=False), + sa.Column("wallet_id", sa.UUID(), nullable=False), + sa.Column("amount", sa.Numeric(precision=10, scale=2), nullable=False), + sa.Column( + "type", + sa.Enum("credit", "debit", name="transactiontypeenum"), + nullable=False, + ), + sa.Column( + "currency", + sa.Enum("USD", "EUR", "RUB", name="currencyenum"), + nullable=False, + ), + sa.Column("timestamp", sa.DateTime(), nullable=False), + sa.ForeignKeyConstraint(["wallet_id"], ["wallet.id"], ondelete="CASCADE"), + sa.PrimaryKeyConstraint("id"), + ) + + +def downgrade(): + # Drop transaction table + op.drop_table("transaction") + + # Drop wallet table + op.drop_table("wallet") + + # Drop enums + op.execute("DROP TYPE IF EXISTS transactiontypeenum") + op.execute("DROP TYPE IF EXISTS currencyenum") 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..e6a5aaaa4c 100644 --- a/backend/app/api/main.py +++ b/backend/app/api/main.py @@ -1,13 +1,17 @@ +"""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, transactions, 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) +api_router.include_router(transactions.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/transactions.py b/backend/app/api/routes/transactions.py new file mode 100644 index 0000000000..8e8d1fbb4f --- /dev/null +++ b/backend/app/api/routes/transactions.py @@ -0,0 +1,63 @@ +"""Transaction management API endpoints.""" + +import uuid + +from fastapi import APIRouter, HTTPException + +from app.api.deps import CurrentUser, SessionDep +from app.constants import NOT_FOUND_CODE +from app.crud import create_transaction, get_wallet_by_id, get_wallet_transactions +from app.models import TransactionCreate, TransactionPublic, TransactionsPublic + +router = APIRouter(prefix="/transactions", tags=["transactions"]) + + +@router.post("/") +def create_wallet_transaction( + *, + session: SessionDep, + current_user: CurrentUser, + transaction_in: TransactionCreate, +) -> TransactionPublic: + """Create a new transaction for a wallet.""" + transaction = create_transaction( + session=session, + transaction_in=transaction_in, + user_id=current_user.id, + ) + return TransactionPublic.model_validate(transaction) + + +@router.get("/wallet/{wallet_id}") +def read_wallet_transactions( + session: SessionDep, + current_user: CurrentUser, + wallet_id: uuid.UUID, + skip: int = 0, + limit: int = 100, +) -> TransactionsPublic: + """Get transactions for a specific wallet.""" + # Verify wallet belongs to user (this is also checked in get_wallet_transactions) + wallet = get_wallet_by_id(session=session, wallet_id=wallet_id) + if not wallet: + raise HTTPException(status_code=NOT_FOUND_CODE, detail="Wallet not found") + + if wallet.user_id != current_user.id and not current_user.is_superuser: + raise HTTPException( + status_code=403, + detail="Not authorized to access this wallet", + ) + + transactions = get_wallet_transactions( + session=session, + wallet_id=wallet_id, + skip=skip, + limit=limit, + ) + transaction_data = [ + TransactionPublic.model_validate(transaction) for transaction in transactions + ] + return TransactionsPublic( + transaction_data=transaction_data, + count=len(transaction_data), + ) 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..09c2595c2e --- /dev/null +++ b/backend/app/api/routes/wallets.py @@ -0,0 +1,59 @@ +"""Wallet management API endpoints.""" + +import uuid + +from fastapi import APIRouter, HTTPException + +from app.api.deps import CurrentUser, SessionDep +from app.constants import BAD_REQUEST_CODE, NOT_FOUND_CODE +from app.crud import create_wallet, get_user_wallets, get_wallet_by_id +from app.models import 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 a new wallet for the current user.""" + wallet = create_wallet( + session=session, + wallet_in=wallet_in, + user_id=current_user.id, + ) + return WalletPublic.model_validate(wallet) + + +@router.get("/") +def read_user_wallets( + session: SessionDep, + current_user: CurrentUser, +) -> WalletsPublic: + """Get all wallets for the current user.""" + wallets = get_user_wallets(session=session, user_id=current_user.id) + wallet_data = [WalletPublic.model_validate(wallet) for wallet in wallets] + return WalletsPublic(wallet_data=wallet_data, count=len(wallet_data)) + + +@router.get("/{wallet_id}") +def read_wallet( + session: SessionDep, + current_user: CurrentUser, + wallet_id: uuid.UUID, +) -> WalletPublic: + """Get wallet details by ID.""" + wallet = get_wallet_by_id(session=session, wallet_id=wallet_id) + if not wallet: + raise HTTPException(status_code=NOT_FOUND_CODE, detail="Wallet not found") + + if wallet.user_id != current_user.id and not current_user.is_superuser: + raise HTTPException( + status_code=BAD_REQUEST_CODE, + detail="Not enough permissions", + ) + + return WalletPublic.model_validate(wallet) 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..08822a9ab7 100644 --- a/backend/app/crud.py +++ b/backend/app/crud.py @@ -1,15 +1,49 @@ +"""CRUD operations for database models.""" + import uuid -from typing import Any +from decimal import Decimal +from fastapi import HTTPException from sqlmodel import Session, select from app.core.security import get_password_hash, verify_password -from app.models import Item, ItemCreate, User, UserCreate, UserUpdate +from app.models import ( + CurrencyEnum, + Item, + ItemCreate, + Transaction, + TransactionCreate, + TransactionTypeEnum, + User, + UserCreate, + UserUpdate, + Wallet, + WalletCreate, +) + + +# Exchange rates (hardcoded for simplicity) +EXCHANGE_RATES = { + ("USD", "EUR"): Decimal("0.85"), + ("USD", "RUB"): Decimal("75.00"), + ("EUR", "USD"): Decimal("1.18"), + ("EUR", "RUB"): Decimal("88.24"), + ("RUB", "USD"): Decimal("0.013"), + ("RUB", "EUR"): Decimal("0.011"), +} + +# Transaction fees (2% for currency conversion) +CONVERSION_FEE_RATE = Decimal("0.02") + +# Maximum wallets per user +MAX_WALLETS_PER_USER = 3 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 +51,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 +66,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 +82,147 @@ 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 + + +# Wallet CRUD operations + + +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 HTTPException( + status_code=400, detail="User cannot have more than 3 wallets" + ) + + # Check if user already has wallet with this currency + existing_currency_wallet = session.exec( + select(Wallet).where( + Wallet.user_id == user_id, Wallet.currency == wallet_in.currency + ) + ).first() + + if existing_currency_wallet: + raise HTTPException( + status_code=400, detail=f"User already has a {wallet_in.currency} wallet" + ) + + 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.""" + return session.exec(select(Wallet).where(Wallet.user_id == user_id)).all() + + +# Transaction CRUD operations + + +def convert_currency( + amount: Decimal, from_currency: CurrencyEnum, to_currency: CurrencyEnum +) -> tuple[Decimal, Decimal]: + """Convert amount between currencies and return (converted_amount, fee).""" + if from_currency == to_currency: + return amount, Decimal("0.00") + + rate_key = (from_currency.value, to_currency.value) + if rate_key not in EXCHANGE_RATES: + raise HTTPException( + status_code=400, + detail=f"Exchange rate not available for {from_currency} to {to_currency}", + ) + + rate = EXCHANGE_RATES[rate_key] + converted_amount = amount * rate + fee = converted_amount * CONVERSION_FEE_RATE + final_amount = converted_amount - fee + + return final_amount, fee + + +def create_transaction( + *, session: Session, transaction_in: TransactionCreate, user_id: uuid.UUID +) -> Transaction: + """Create a new transaction.""" + # Get the wallet + wallet = session.get(Wallet, transaction_in.wallet_id) + if not wallet: + raise HTTPException(status_code=404, detail="Wallet not found") + + # Check if wallet belongs to user + if wallet.user_id != user_id: + raise HTTPException( + status_code=403, detail="Not authorized to access this wallet" + ) + + # Convert currency if needed + transaction_amount = transaction_in.amount + if transaction_in.currency != wallet.currency: + converted_amount, _ = convert_currency( + transaction_in.amount, transaction_in.currency, wallet.currency + ) + transaction_amount = converted_amount + + # Calculate new balance + if transaction_in.type == TransactionTypeEnum.CREDIT: + new_balance = wallet.balance + transaction_amount + else: # DEBIT + new_balance = wallet.balance - transaction_amount + + # Check for negative balance + if new_balance < 0: + raise HTTPException( + status_code=400, + detail="Insufficient funds: transaction would result in negative balance", + ) + + # Create transaction + db_transaction = Transaction.model_validate(transaction_in) + session.add(db_transaction) + + # Update wallet balance + wallet.balance = new_balance + session.add(wallet) + + 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.""" + return session.exec( + select(Transaction) + .where(Transaction.wallet_id == wallet_id) + .offset(skip) + .limit(limit) + .order_by(Transaction.timestamp.desc()) + ).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..bc7bdb7c59 100644 --- a/backend/app/models.py +++ b/backend/app/models.py @@ -1,113 +1,317 @@ +"""Data models for the application.""" + import uuid +from datetime import 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="owner", 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 models + + +class CurrencyEnum(str, Enum): + """Available currency types.""" + + USD = "USD" + EUR = "EUR" + RUB = "RUB" + + +class TransactionTypeEnum(str, Enum): + """Transaction type enum.""" + + CREDIT = "credit" + DEBIT = "debit" + + +# Shared properties for Wallet +class WalletBase(SQLModel): + """Base wallet model with shared fields.""" + + currency: CurrencyEnum = Field(description="Wallet currency") + balance: Decimal = Field( + default=Decimal("0.00"), + decimal_places=2, + description="Wallet balance", + ) + + +# Properties to receive via API on wallet creation +class WalletCreate(SQLModel): + """Wallet creation model.""" + + currency: CurrencyEnum + + +# Properties to receive via API on wallet update +class WalletUpdate(SQLModel): + """Wallet update model.""" + + balance: Decimal | None = Field(default=None, decimal_places=2) + + +# Database model for Wallet +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", + ) + owner: User | None = Relationship(back_populates="wallets") + transactions: list["Transaction"] = Relationship( + back_populates="wallet", + cascade_delete=True, + ) + + +# Properties to return via API +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 + + +# Shared properties for Transaction +class TransactionBase(SQLModel): + """Base transaction model with shared fields.""" + + amount: Decimal = Field(decimal_places=2, description="Transaction amount") + type: TransactionTypeEnum = Field(description="Transaction type") + currency: CurrencyEnum = Field(description="Transaction currency") + timestamp: datetime = Field( + default_factory=datetime.now, + description="Transaction timestamp", + ) + + +# Properties to receive via API on transaction creation +class TransactionCreate(SQLModel): + """Transaction creation model.""" + + wallet_id: uuid.UUID + amount: Decimal = Field( + decimal_places=2, + gt=0, + description="Transaction amount must be positive", + ) + type: TransactionTypeEnum + currency: CurrencyEnum + + +# Database model for Transaction +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") + + +# Properties to return via API +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..5783094556 --- /dev/null +++ b/code_quality_analysis.ipynb @@ -0,0 +1,1154 @@ +{ + "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": 4, + "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": 5, + "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": 6, + "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": 7, + "id": "0db8c239", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ruff found 88 linting issues\n", + "\n", + "Ruff Results Summary:\n", + "Top 10 most common rules:\n", + "rule_code\n", + "Q000 37\n", + "W293 19\n", + "COM812 17\n", + "E501 4\n", + "I001 2\n", + "ANN201 2\n", + "D103 2\n", + "W291 2\n", + "D400 1\n", + "D415 1\n", + "Name: count, dtype: int64\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": 8, + "id": "2a1f0732", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MyPy found 9 type checking issues\n", + "\n", + "MyPy Results Summary:\n", + "severity\n", + "error 7\n", + "note 2\n", + "Name: count, dtype: int64\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": 9, + "id": "5b0cf9e3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Radon CC analyzed 188 functions/methods (all ranks included)\n", + "\n", + "Radon CC Results Summary:\n", + "Average complexity: 2.24\n", + "Complexity rank distribution:\n", + "rank\n", + "A 181\n", + "B 7\n", + "Name: count, dtype: int64\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": 10, + "id": "6820f645", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Radon MI analyzed 49 files (all ranks included)\n", + "\n", + "Radon MI Results Summary:\n", + "Average maintainability index: 80.75\n", + "MI rank distribution:\n", + "mi_rank\n", + "A 49\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": 11, + "id": "e3918fd3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Flake8 WPS found 16 style issues\n", + "\n", + "Flake8 WPS Results Summary:\n", + "Top 10 most common WPS rules:\n", + "rule_code\n", + "WPS432 7\n", + "WPS202 4\n", + "WPS226 3\n", + "WPS235 1\n", + "WPS407 1\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": 12, + "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 88 3\n", + "mypy 9 2\n", + "radon_cc 7 4\n", + "radon_mi 0 0\n", + "flake8_wps 16 5\n", + "\n", + "Total combined issues (excluding Radon A ranks): 122\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": 13, + "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": 14, + "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": 15, + "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": 16, + "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): 122\n", + " Files Analyzed (max across tools): 5\n", + " Average Issues per File: 24.40\n", + "\n", + "🔍 TOOL BREAKDOWN:\n", + " BANDIT: 2 issues across 2 files\n", + " RUFF: 88 issues across 3 files\n", + " MYPY: 9 issues across 2 files\n", + " RADON_CC: 7 issues across 4 files\n", + " RADON_MI: 0 issues across 0 files\n", + " FLAKE8_WPS: 16 issues across 5 files\n", + "\n", + "💡 QUALITY INSIGHTS:\n", + " 🚨 Security: 0 high-severity security issues found\n", + " 🔄 Complexity: Average CC (all ranks) = 2.24, 0 functions with CC > 10\n", + " 🛠️ Maintainability: Average MI (all ranks) = 80.75, 0 files with MI < 20 (needs attention)\n", + "\n", + "📋 RECOMMENDATIONS:\n", + " 1. Address 122 total issues found across all tools\n", + " 2. Security: Review and fix 2 security issues\n", + " 5. Style: Focus on fixing Q000 rule violations first\n", + "\n", + "================================================================================\n", + "\n", + "FINAL SUMMARY TABLE:\n", + " Tool Total Issues (A excl) Files Analyzed Issues per File\n", + " bandit 2 2 1.000000\n", + " ruff 88 3 29.333333\n", + " mypy 9 2 4.500000\n", + " radon_cc 7 4 1.750000\n", + " radon_mi 0 0 0.000000\n", + "flake8_wps 16 5 3.200000\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", + "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/code_quality_summary.csv b/code_quality_summary.csv new file mode 100644 index 0000000000..676098852e --- /dev/null +++ b/code_quality_summary.csv @@ -0,0 +1,7 @@ +Tool,Total Issues (A excl),Files Analyzed,Issues per File +bandit,2,2,1.0 +ruff,88,3,29.333333333333332 +mypy,9,2,4.5 +radon_cc,7,4,1.75 +radon_mi,0,0,0.0 +flake8_wps,16,5,3.2 diff --git a/detailed_issues.csv b/detailed_issues.csv new file mode 100644 index 0000000000..66edec96d4 --- /dev/null +++ b/detailed_issues.csv @@ -0,0 +1,123 @@ +tool,file,line,severity +bandit,backend/app/core/config.py,111,LOW +bandit,backend/app/models.py,19,LOW +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,1,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,1,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,8,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,10,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,14,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,15,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,20,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,20,warning +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,23,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,24,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,25,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,26,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,26,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,26,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,26,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,26,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,26,warning +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,27,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,28,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,28,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,28,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,29,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,29,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,31,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,34,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,35,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,36,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,37,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,38,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,38,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,38,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,38,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,38,warning +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,39,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,39,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,39,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,39,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,39,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,39,warning +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,40,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,41,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,41,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,41,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,42,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,42,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,46,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,46,warning +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,48,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,49,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,51,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,52,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,54,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,55,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/api/routes/wallets.py,56,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/api/routes/wallets.py,62,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,3,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,105,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,107,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,111,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,113,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,118,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,119,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,121,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,125,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,127,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,130,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,146,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,154,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,155,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,156,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,161,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,166,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,168,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,173,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,181,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,188,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,193,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,195,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,202,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,205,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,211,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,216,warning +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,216,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,218,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,222,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,226,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,237,error +ruff,/Users/somen/Zavodi/opensource/fastapi-moscow-python-demo/backend/app/crud.py,245,error +mypy,backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,16,error +mypy,backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,17,error +mypy,backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,20,error +mypy,backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,20,note +mypy,backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,46,error +mypy,backend/app/alembic/versions/fd8dcfe8d4fd_add_wallet_and_transaction_models.py,46,note +mypy,backend/app/crud.py,145,error +mypy,backend/app/crud.py,240,error +mypy,backend/app/crud.py,245,error +radon_cc,backend/app/email_utils.py,36,B +radon_cc,backend/app/crud.py,177,B +radon_cc,backend/app/tests/api/routes/test_items.py,27,B +radon_cc,backend/app/tests/api/routes/test_items.py,45,B +radon_cc,backend/app/tests/api/routes/test_items.py,107,B +radon_cc,backend/app/tests/api/routes/test_users.py,357,B +radon_cc,backend/app/tests/api/routes/test_users.py,232,B +flake8_wps,backend/app/api/routes/transactions.py,51,warning +flake8_wps,backend/app/api/routes/users.py,0,warning +flake8_wps,backend/app/crud.py,0,warning +flake8_wps,backend/app/crud.py,10,warning +flake8_wps,backend/app/crud.py,26,warning +flake8_wps,backend/app/crud.py,27,warning +flake8_wps,backend/app/crud.py,27,warning +flake8_wps,backend/app/crud.py,28,warning +flake8_wps,backend/app/crud.py,110,warning +flake8_wps,backend/app/crud.py,124,warning +flake8_wps,backend/app/crud.py,165,warning +flake8_wps,backend/app/crud.py,187,warning +flake8_wps,backend/app/crud.py,192,warning +flake8_wps,backend/app/crud.py,215,warning +flake8_wps,backend/app/email_utils.py,0,warning +flake8_wps,backend/app/models.py,0,warning 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" }, +]