pyproject.toml

[project]
authors = [
  { name = "Cody Fincher", email = "cody.fincher@gmail.com" },
  { name = "Peter Schutt", email = "peter.github@proton.me" },
  { name = "Janek Nouvertné", email = "j.a.nouvertne@posteo.de" },
  { name = "Jacob Coffee", email = "jacob@z7x.org" },
]
classifiers = [
  "Development Status :: 3 - Alpha",
  "Environment :: Web Environment",
  "License :: OSI Approved :: MIT License",
  "Natural Language :: English",
  "Operating System :: OS Independent",
  "Programming Language :: Python :: 3.9",
  "Programming Language :: Python :: 3.10",
  "Programming Language :: Python :: 3.11",
  "Programming Language :: Python :: 3.12",
  "Programming Language :: Python :: 3.13",
  "Programming Language :: Python",
  "Topic :: Software Development",
  "Typing :: Typed",
  "Intended Audience :: Developers",
  "Intended Audience :: System Administrators",
  "Topic :: Database",
  "Topic :: Database :: Database Engines/Servers",
]
dependencies = [
  "sqlalchemy>=2.0.20",
  "alembic>=1.12.0",
  "typing-extensions>=4.0.0",
  "greenlet",
  "eval-type-backport ; python_full_version < '3.10'",
]
description = "Ready-to-go SQLAlchemy concoctions."
keywords = ["sqlalchemy", "alembic", "litestar", "sanic", "fastapi", "flask"]
license = { text = "MIT" }
maintainers = [
  { name = "Litestar Developers", email = "hello@litestar.dev" },
  { name = "Cody Fincher", email = "cody@litestar.dev" },
  { name = "Jacob Coffee", email = "jacob@litestar.dev" },
  { name = "Janek Nouvertné", email = "janek@litestar.dev" },
  { name = "Julien Courtes", email = "julien@litestar.dev" },
]
name = "advanced_alchemy"
readme = "README.md"
requires-python = ">=3.9"
version = "0.34.0"

[project.urls]
Changelog = "https://docs.advanced-alchemy.litestar.dev/latest/changelog"
Discord = "https://discord.gg/litestar"
Documentation = "https://docs.advanced-alchemy.litestar.dev/latest/"
Funding = "https://github.com/sponsors/litestar-org"
Homepage = "https://docs.advanced-alchemy.litestar.dev/latest/"
Issue = "https://github.com/litestar-org/advanced-alchemy/issues/"
Source = "https://github.com/litestar-org/advanced-alchemy"

[project.optional-dependencies]
cli = ["rich-click"]
nanoid = ["fastnanoid>=0.4.1"]
uuid = ["uuid-utils>=0.6.1"]

[project.scripts]
alchemy = "advanced_alchemy.__main__:run_cli"

[dependency-groups]
build = ["bump-my-version"]
cockroachdb = [
  "asyncpg>=0.29.0",
  "psycopg2-binary>=2.9.10",
  "psycopg[binary,pool]>=3.2.3",
  "sqlalchemy-cockroachdb>=2.0.2",
]
dev = [
  { include-group = "build" },
  { include-group = "lint" },
  { include-group = "doc" },
  { include-group = "test" },
  { include-group = "litestar" },
  { include-group = "fastapi" },
  { include-group = "flask" },
  { include-group = "sanic" },
  { include-group = "sqlite" },
  { include-group = "oracle" },
  { include-group = "duckdb" },
  { include-group = "mssql" },
  { include-group = "mysql" },
  { include-group = "spanner" },
  { include-group = "cockroachdb" },
  { include-group = "postgres" },
]
doc = [
  "auto-pytabs[sphinx]>=0.5.0",
  "git-cliff>=2.6.1",
  "shibuya",
  "sphinx>=7.0.0; python_version <= \"3.9\"",
  "sphinx>=8.0.0; python_version >= \"3.10\"",
  "sphinx-autobuild>=2021.3.14",
  "sphinx-copybutton>=0.5.2",
  "sphinx-click>=6.0.0",
  "sphinx-design>=0.5.0",
  "sphinxcontrib-mermaid>=0.9.2",
  "sphinx-paramlinks>=0.6.0",
  "sphinx-togglebutton>=0.3.2",
  "sphinx-toolbox>=3.8.1",
  "myst-parser",
  "sphinx-autodoc-typehints",
]
duckdb = ["duckdb>=1.1.2", "duckdb-engine>=0.13.4", "pytz>=2024.2"]
fastapi = ["fastapi[all]>=0.115.3", "starlette"]
flask = ["flask-sqlalchemy>=3.1.1", "flask[async]"]
lint = [
  "mypy>=1.13.0",
  "pre-commit>=3.5.0",
  "pyright>=1.1.386",
  "ruff>=0.7.1",
  "slotscheck>=0.16.5",
  "asyncpg-stubs",
  "types-Pillow",
  "types-PyMySQL",
  "types-PyYAML",
  "types-Pygments",
  "types-aiofiles",
  "types-colorama",
  "types-docutils",
  "types-psycopg2",
  "types-python-dateutil",
  "types-pytz",
  "types-ujson",
]
litestar = ["litestar[cli]>=2.15.0"]
mssql = ["aioodbc>=0.5.0", "pyodbc>=5.2.0"]
mysql = ["asyncmy>=0.2.9"]
oracle = ["oracledb>=2.4.1"]
postgres = ["asyncpg>=0.29.0", "psycopg2-binary>=2.9.10", "psycopg[binary,pool]>=3.2.3"]
sanic = ["sanic", "sanic-testing>=24.6.0", "sanic[ext]>=24.6.0"]
spanner = ["sqlalchemy-spanner>=1.7.0"]
sqlite = ["aiosqlite>=0.20.0"]
test = [
  "pydantic-extra-types",
  "rich-click",
  "coverage>=7.6.1",
  "pytest>=7.4.4",
  "pytest-asyncio>=0.23.8",
  "pytest-cov>=5.0.0",
  "pytest-databases",
  "pytest-lazy-fixtures>=1.1.1",
  "pytest-rerunfailures",
  "pytest-mock>=3.14.0",
  "pytest-sugar>=1.0.0",
  "pytest-xdist>=3.6.1",
  "pytest-click",
  "asgi-lifespan",
  "click",
  "time-machine>=2.15.0",
]

[tool.bumpversion]
allow_dirty = true
commit = false
commit_args = "--no-verify"
current_version = "0.34.0"
ignore_missing_files = false
ignore_missing_version = false
message = "chore(release): bump to v{new_version}"
parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
regex = false
replace = "{new_version}"
search = "{current_version}"
serialize = ["{major}.{minor}.{patch}"]
sign_tags = false
tag = false
tag_message = "chore(release): v{new_version}"
tag_name = "v{new_version}"

[[tool.bumpversion.files]]
filename = "pyproject.toml"
replace = 'version = "{new_version}"'
search = 'version = "{current_version}"'

[[tool.bumpversion.files]]
filename = "uv.lock"
replace = """
name = "advanced-alchemy"
version = "{new_version}"
"""
search = """
name = "advanced-alchemy"
version = "{current_version}"
"""

[build-system]
build-backend = "hatchling.build"
requires = ["hatchling"]

[tool.hatch.build.targets.wheel]
packages = [
  "advanced_alchemy",
  "advanced_alchemy.extensions.litestar",
  "advanced_alchemy.extensions.sanic",
  "advanced_alchemy.extensions.starlette",
]

[tool.pytest.ini_options]
addopts = ["-q", "-ra"]
asyncio_default_fixture_loop_scope = "function"
asyncio_mode = "auto"
filterwarnings = [
  "ignore::DeprecationWarning:pkg_resources.*",
  "ignore:pkg_resources is deprecated as an API:DeprecationWarning",
  "ignore::DeprecationWarning:pkg_resources",
  "ignore::DeprecationWarning:google.rpc",
  "ignore::DeprecationWarning:google.gcloud",
  "ignore::DeprecationWarning:google.iam",
  "ignore::DeprecationWarning:google",
  "ignore::DeprecationWarning:websockets.connection",
  "ignore::DeprecationWarning:websockets.legacy",
]
markers = [
  "integration: SQLAlchemy integration tests",
  "asyncmy: SQLAlchemy MySQL (asyncmy) Tests",
  "asyncpg: SQLAlchemy Postgres (asyncpg) Tests",
  "psycopg_async: SQLAlchemy Postgres (psycopg async) Tests",
  "psycopg_sync: SQLAlchemy Postgres (psycopg sync) Tests",
  "aiosqlite: SQLAlchemy SQLite (aiosqlite) Tests",
  "sqlite: SQLAlchemy SQLite (sqlite) Tests",
  "oracledb_sync: SQLAlchemy Oracle (oracledb sync) Tests",
  "oracledb_async: SQLAlchemy Oracle (oracledb async) Tests",
  "spanner: SQLAlchemy Google Cloud Spanner (sqlalchemy-spanner) Tests",
  "duckdb: SQLAlchemy DuckDB (duckdb-engine) Tests",
  "mssql_sync: SQLAlchemy Microsoft SQL Server (pyodbc) Tests",
  "mssql_async: SQLAlchemy Microsoft SQL Server (aioodbc) Tests",
  "mock_async: SQLAlchemy async mock Tests",
  "mock_sync: SQLAlchemy sync mock Tests",
  "cockroachdb_sync: SQLAlchemy CockroachDB (psycopg2) Tests",
  "cockroachdb_async: SQLAlchemy CockroachDB (asyncpg) Tests",
]
testpaths = ["tests"]

[tool.coverage.run]
branch = true
concurrency = ["multiprocessing"]
omit = [
  "*/tests/*",
  "advanced_alchemy/alembic/templates/asyncio/env.py",
  "advanced_alchemy/alembic/templates/sync/env.py",
  "advanced_alchemy/extensions/litestar/cli.py",
  "advanced_alchemy/alembic/commands.py",
  "advanced_alchemy/types.py",
  "advanced_alchemy/operations.py",
  "advanced_alchemy/service/*",
]
parallel = true
relative_files = true

[tool.coverage.report]
exclude_lines = [
  'pragma: no cover',
  'if TYPE_CHECKING:',
  'except ImportError as e:',
  'except ImportError:',
  '\.\.\.',
  'raise NotImplementedError',
  'if VERSION.startswith("1"):',
  'if pydantic.VERSION.startswith("1"):',
]

[tool.black]
line-length = 120

[tool.ruff]
exclude = [".venv", "node_modules"]
line-length = 120
src = ["advanced_alchemy", "tests", "docs", "tools"]
target-version = "py39"

[tool.ruff.format]
docstring-code-format = true
docstring-code-line-length = 60

[tool.ruff.lint]
extend-safe-fixes = ["TC"]
fixable = ["ALL"]
ignore = [
  "A003",    # flake8-builtins - class attribute {name} is shadowing a python builtin
  "A005",    # flake8-builtins - module {name} shadows a Python standard-library module
  "B010",    # flake8-bugbear - do not call setattr with a constant attribute value
  "D100",    # pydocstyle - missing docstring in public module
  "D101",    # pydocstyle - missing docstring in public class
  "D102",    # pydocstyle - missing docstring in public method
  "D103",    # pydocstyle - missing docstring in public function
  "D104",    # pydocstyle - missing docstring in public package
  "D105",    # pydocstyle - missing docstring in magic method
  "D106",    # pydocstyle - missing docstring in public nested class
  "D107",    # pydocstyle - missing docstring in __init__
  "D202",    # pydocstyle - no blank lines allowed after function docstring
  "D205",    # pydocstyle - 1 blank line required between summary line and description
  "D415",    # pydocstyle - first line should end with a period, question mark, or exclamation point
  "E501",    # pydocstyle line too long, handled by black
  "PLW2901", # pylint - for loop variable overwritten by assignment target
  "RUF012",  # Ruff-specific rule - annotated with classvar
  "ANN401",
  "FBT",
  "PLR0913", # too many arguments
  "PT",
  "TD",
  "ARG002",  # ignore for now; investigate
  "ARG003",  # ignore for now; investigate
  "PERF203", # ignore for now; investigate
  "PD011",   # pandas
  "PLR0912",
  "ISC001",
  "COM812",
  "CPY001",
  "FA100",
]
select = ["ALL"]

[tool.ruff.lint.pydocstyle]
convention = "google"

[tool.ruff.lint.pyupgrade]
# Preserve types, even if a file imports `from __future__ import annotations`.
# keep-runtime-typing = true

[tool.ruff.lint.mccabe]
max-complexity = 14

[tool.ruff.lint.pep8-naming]
classmethod-decorators = [
  "sqlalchemy.ext.declarative.declared_attr",
  "sqlalchemy.orm.declared_attr.directive",
  "sqlalchemy.orm.declared_attr",
]

[tool.ruff.lint.per-file-ignores]
"advanced_alchemy/repository/*.py" = ['C901']
"examples/flask.py" = ["ANN"]
"examples/flask/*.py" = ["ANN"]
"tests/**/*.*" = [
  "A",
  "ARG",
  "B",
  "BLE",
  "C901",
  "D",
  "DTZ",
  "EM",
  "FBT",
  "G",
  "N",
  "PGH",
  "PIE",
  "PLR",
  "PLW",
  "PTH",
  "RSE",
  "S",
  "S101",
  "SIM",
  "TC",
  "TRY",
  "SLF001",
]

[tool.ruff.lint.flake8-tidy-imports]
# Disallow all relative imports.
ban-relative-imports = "all"

[tool.ruff.lint.isort]
known-first-party = ["advanced_alchemy", "tests"]

[tool.slotscheck]
exclude-modules = '''
(
  (^|\.)test_
  |^tests\.*
  |^tools\.*
  |^docs\.*
  |^examples\.*
  |^sqlalchemy\.(
    testing
    |ext\.mypy  # see slotscheck/issues/178
  )
  |^alembic\.testing\.suite.*  # Add this line to exclude Alembic test suite
)
'''
include-modules = "advanced_alchemy.*"
require-superclass = false
strict-imports = true

[tool.mypy]
disallow_any_generics = false
disallow_untyped_decorators = true
implicit_reexport = false
packages = ["advanced_alchemy", "tests", "docs", "examples"]
python_version = "3.9"
show_error_codes = true
strict = true
warn_redundant_casts = true
warn_return_any = true
warn_unreachable = true
warn_unused_configs = true
warn_unused_ignores = true

[[tool.mypy.overrides]]
disable_error_code = "attr-defined,type-var,union-attr"
disallow_untyped_decorators = false
module = "tests.*"
warn_unused_ignores = false

[[tool.mypy.overrides]]
ignore_missing_imports = true
module = [
  "asyncmy",
  "pyodbc",
  "greenlet",
  "google.auth.*",
  "google.cloud.*",
  "google.protobuf.*",
  "pyarrow.*",
  "pytest_docker.*",
  "googleapiclient",
  "googleapiclient.*",
  "uuid_utils",
  "uuid_utils.*",
]

[[tool.mypy.overrides]]
module = "advanced_alchemy._serialization"
warn_unused_ignores = false

[[tool.mypy.overrides]]
disallow_untyped_decorators = false
module = "advanced_alchemy.extensions.litestar.cli"

[[tool.mypy.overrides]]
disallow_untyped_decorators = false
module = "advanced_alchemy.types.json"

[[tool.mypy.overrides]]
module = "advanced_alchemy.service.typing"
warn_unused_ignores = false

[[tool.mypy.overrides]]
module = "advanced_alchemy.alembic.templates.*.env"
warn_unreachable = false

[[tool.mypy.overrides]]
disable_error_code = "no-untyped-call"
disallow_untyped_decorators = false
module = "advanced_alchemy.extensions.sanic"
warn_unused_ignores = false

[[tool.mypy.overrides]]
module = "advanced_alchemy.base"
warn_unused_ignores = false

[[tool.mypy.overrides]]
disallow_untyped_decorators = false
module = "advanced_alchemy.extensions.litestar.cli"

[[tool.mypy.overrides]]
disable_error_code = "arg-type,no-any-return,no-untyped-def"
disallow_untyped_decorators = false
disallow_untyped_defs = false
module = "examples.flask.*"

[[tool.mypy.overrides]]
disable_error_code = "unreachable"
module = "tests.integration.test_repository"


[tool.pyright]
disableBytesTypePromotions = true
exclude = [
  "docs",
  "tests/unit/test_extensions",
  "tests/unit/test_repository.py",
  "tests/helpers.py",
  "tests/docker_service_fixtures.py",
  "examples/flask/flask_services.py",
]
include = ["advanced_alchemy"]
pythonVersion = "3.9"
reportUnnecessaryTypeIgnoreComments = true
reportUnusedFunction = false
strict = ["advanced_alchemy/**/*"]
venv = ".venv"
venvPath = "."

[tool.unasyncd]
add_editors_note = true
cache = true
ruff_fix = true
ruff_format = true
update_docstrings = true

[tool.unasyncd.files]
"advanced_alchemy/repository/_async.py" = "advanced_alchemy/repository/_sync.py"
"advanced_alchemy/repository/memory/_async.py" = "advanced_alchemy/repository/memory/_sync.py"
"advanced_alchemy/service/_async.py" = "advanced_alchemy/service/_sync.py"

[tool.unasyncd.per_file_add_replacements."advanced_alchemy/repository/_async.py"]
SQLAlchemyAsyncMockRepository = "SQLAlchemySyncMockRepository"
"SQLAlchemyAsyncQueryRepository" = "SQLAlchemySyncQueryRepository"
SQLAlchemyAsyncRepository = "SQLAlchemySyncRepository"
SQLAlchemyAsyncRepositoryProtocol = "SQLAlchemySyncRepositoryProtocol"
"SQLAlchemyAsyncSlugRepository" = "SQLAlchemySyncSlugRepository"
SQLAlchemyAsyncSlugRepositoryProtocol = "SQLAlchemySyncSlugRepositoryProtocol"
"async_scoped_session" = "scoped_session"
"sqlalchemy.ext.asyncio.AsyncSession" = "sqlalchemy.orm.Session"
"sqlalchemy.ext.asyncio.scoping.async_scoped_session" = "sqlalchemy.orm.scoping.scoped_session"

[tool.unasyncd.per_file_add_replacements."advanced_alchemy/repository/memory/_async.py"]
SQLAlchemyAsyncMockRepository = "SQLAlchemySyncMockRepository"
"SQLAlchemyAsyncMockSlugRepository" = "SQLAlchemySyncMockSlugRepository"
SQLAlchemyAsyncRepository = "SQLAlchemySyncRepository"
SQLAlchemyAsyncRepositoryProtocol = "SQLAlchemySyncRepositoryProtocol"
"SQLAlchemyAsyncSlugRepository" = "SQLAlchemySyncSlugRepository"
SQLAlchemyAsyncSlugRepositoryProtocol = "SQLAlchemySyncSlugRepositoryProtocol"
"advanced_alchemy.repository._async.SQLAlchemyAsyncRepositoryProtocol" = "advanced_alchemy.repository._sync.SQLAlchemySyncRepositoryProtocol"
"advanced_alchemy.repository._async.SQLAlchemyAsyncSlugRepositoryProtocol" = "advanced_alchemy.repository._sync.SQLAlchemySyncSlugRepositoryProtocol"
"async_scoped_session" = "scoped_session"
"sqlalchemy.ext.asyncio.AsyncEngine" = "sqlalchemy.Engine"
"sqlalchemy.ext.asyncio.AsyncSession" = "sqlalchemy.orm.Session"
"sqlalchemy.ext.asyncio.scoping.async_scoped_session" = "sqlalchemy.orm.scoping.scoped_session"

[tool.unasyncd.per_file_add_replacements."advanced_alchemy/service/_async.py"]
"AsyncIterator" = "Iterator"
"SQLAlchemyAsyncConfigT" = "SQLAlchemySyncConfigT"
SQLAlchemyAsyncMockRepository = "SQLAlchemySyncMockRepository"
SQLAlchemyAsyncMockSlugRepository = "SQLAlchemySyncMockSlugRepository"
SQLAlchemyAsyncQueryService = "SQLAlchemySyncQueryService"
SQLAlchemyAsyncRepository = "SQLAlchemySyncRepository"
SQLAlchemyAsyncRepositoryReadService = "SQLAlchemySyncRepositoryReadService"
SQLAlchemyAsyncRepositoryService = "SQLAlchemySyncRepositoryService"
"SQLAlchemyAsyncRepositoryT" = "SQLAlchemySyncRepositoryT"
SQLAlchemyAsyncSlugRepository = "SQLAlchemySyncSlugRepository"
"advanced_alchemy.config.asyncio.SQLAlchemyAsyncConfig" = "advanced_alchemy.config.sync.SQLAlchemySyncConfig"
"advanced_alchemy.repository.SQLAlchemyAsyncQueryRepository" = "advanced_alchemy.repository.SQLAlchemySyncQueryRepository"
"advanced_alchemy.repository.SQLAlchemyAsyncRepository" = "advanced_alchemy.repository.SQLAlchemySyncRepository"
"advanced_alchemy.repository.SQLAlchemyAsyncRepositoryProtocol" = "advanced_alchemy.repository.SQLAlchemySyncRepositoryProtocol"
"advanced_alchemy.repository.SQLAlchemyAsyncSlugRepository" = "advanced_alchemy.repository.SQLAlchemySyncSlugRepository"
"advanced_alchemy.repository.SQLAlchemyAsyncSlugRepositoryProtocol" = "advanced_alchemy.repository.SQLAlchemySyncSlugRepositoryProtocol"
"advanced_alchemy.repository.memory.SQLAlchemyAsyncMockRepository" = "advanced_alchemy.repository.memory.SQLAlchemySyncMockRepository"
"advanced_alchemy.repository.memory.SQLAlchemyAsyncMockSlugRepository" = "advanced_alchemy.repository.memory.SQLAlchemySyncMockSlugRepository"
"advanced_alchemy.repository.typing.SQLAlchemyAsyncRepositoryT" = "advanced_alchemy.repository.typing.SQLAlchemySyncRepositoryT"
"async_scoped_session" = "scoped_session"
"collections.abc.AsyncIterator" = "collections.abc.Iterator"
"sqlalchemy.ext.asyncio.AsyncSession" = "sqlalchemy.orm.Session"
"sqlalchemy.ext.asyncio.scoping.async_scoped_session" = "sqlalchemy.orm.scoping.scoped_session"

[tool.codespell]
ignore-words-list = "selectin"
skip = 'pdm.lock, uv.lock, examples/us_state_lookup.json, docs/_static/favicon.svg'