typing-arguments 0.1.0__tar.gz

typing_arguments-0.1.0/.github/dependabot.yml

@@ -0,0 +1,16 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    assignees:
+      - "ddanier"
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    ignore:
+      - dependency-name: "pydantic"
+    assignees:
+      - "ddanier"

typing_arguments-0.1.0/.github/workflows/lint.yml

@@ -0,0 +1,24 @@
+name: "LINT: Run ruff & pyright"
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '0 7 * * 1'
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      - name: Install dependencies
+        run: |
+          uv sync --group dev
+      - name: Lint with ruff & pyright
+        run: |
+          uv run ruff check typing_arguments tests
+          uv run pyright typing_arguments

typing_arguments-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,26 @@
+name: "RELEASE: Upload Python Package to PyPI"
+on:
+  release:
+    types: [published]
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+      - name: Install dependencies
+        run: |
+          uv sync
+      - name: Build package
+        run: uv build
+      - name: Publish package
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}

typing_arguments-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,26 @@
+name: "TEST: Run pytest using tox"
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '0 7 * * 1'
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.9", "3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          uv sync --group dev
+      - name: Test with pytest
+        run: |
+          uv run tox -e 'py'

typing_arguments-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+/build/
+/dist/
+/wheels/
+/*.egg-info
+/uv.lock
+/.coverage
+/.tox
+
+# Virtual environments
+/.venv

typing_arguments-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,26 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: end-of-file-fixer
+      - id: check-added-large-files
+      - id: check-merge-conflict
+      - id: check-docstring-first
+      - id: debug-statements
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.0
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+  - repo: https://github.com/alessandrojcm/commitlint-pre-commit-hook
+    rev: v9.18.0
+    hooks:
+      - id: commitlint
+        stages: [commit-msg]
+        additional_dependencies:
+          - "@commitlint/config-conventional"
+default_stages:
+  - pre-commit
+default_install_hook_types:
+  - pre-commit
+  - commit-msg

typing_arguments-0.1.0/.python-version

@@ -0,0 +1 @@
+3.10

typing_arguments-0.1.0/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2024 TEAM23 GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.

typing_arguments-0.1.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.3
+Name: typing-arguments
+Version: 0.1.0
+Summary: Store references of your typing arguments to be available at runtime.
+Project-URL: Repository, https://github.com/team23/typing-arguments
+Author-email: TEAM23 GmbH <info@team23.de>
+License: The MIT License (MIT)
+        Copyright (c) 2024 TEAM23 GmbH
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+        IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+        DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+        OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+        OR OTHER DEALINGS IN THE SOFTWARE.
+Requires-Python: >=3.10
+Provides-Extra: pydantic
+Requires-Dist: pydantic<3.0.0,>=2.0.0; extra == 'pydantic'
+Description-Content-Type: text/markdown
+
+# `typing-arguments`
+
+Typing arguments using the `Generic` base class in python are great, but they lack the ability to
+easily access the type arguments at runtime. This library provides a mixin class that can be used
+to make type arguments available in the class and its instances.
+
+This is also true for classes based on `pydantic.BaseModel` for pydantic > 2.x.
+
+## Installation
+
+Just use `pip install typing-arguments` to install the library.
+
+**Note:** `typing-arguments` is tested on Python `3.10`, `3.11`, `3.12` and `3.13`. This is also ensured running
+all tests on all those versions using `tox`.
+
+## Usage
+
+### Quick Example
+
+```python
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", bound="SomeBaseClass")
+
+
+class Something(
+    GenericArgumentsMixin,
+    Generic[T1, T2],
+):
+    t1 = typing_arg(T1)
+    t2 = typing_arg(T2)
+
+
+ConcreteClass = Something[str, SomeBaseClassChild]
+ConcreteClass.t1  # str
+ConcreteClass.t2  # SomeBaseClassChild
+```
+
+**Hint:** You may also use this with pydantic models:
+
+```python
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", bound="SomeBaseClass")
+
+
+class SomethingModel(
+    GenericArgumentsMixin,
+    BaseModel,
+    Generic[T1, T2],
+):
+    t1: ClassVar = typing_arg(T1)
+    t2: ClassVar = typing_arg(T2)
+
+
+ConcreteClassModel = SomethingModel[str, SomeBaseClassChild]
+ConcreteClassModel.t1  # str
+ConcreteClassModel.t2  # SomeBaseClassChild
+```
+
+Internally `GenericArgumentsMixin` will create a new attribute `__typing_arguments__`
+inside the class and its instances. This attribute is a dictionary mapping the type
+variables to their concrete types. This is useful if you want to access the type
+arguments in a generic way.
+
+The `typing_arg` function is a helper function to make the type arguments available
+in the class and its instances using a nicely named attribute. This is just a
+convenience function, as you can also access the type arguments directly from the
+`__typing_arguments__` attribute.
+
+**Note:** If you are using pydantic models you should use the `ClassVar` annotation
+to ensure pydantic will not try to catch and validate the type arguments as normal
+model fields.
+
+You may also mix different generic base classes like so:
+
+```python
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", bound="SomeBaseClass")
+
+
+class Base1(
+    GenericArgumentsMixin,
+    Generic[T1],
+):
+    pass
+
+
+class Base2(
+    GenericArgumentsMixin,
+    Generic[T2],
+):
+    t2 = typing_arg(T2)
+
+
+class Something(
+    Base1[str],
+    Base2[SomeBaseClassChild],
+):
+    t1 = typing_arg(T1)
+
+
+Something.t1  # str
+Something.t2  # SomeBaseClassChild
+```
+
+In this example `Base1` and `Base2` are both generic base classes. `Base1` only
+defines a type argument `T1` and `Base2` only defines a type argument `T2`. The
+`Something` class inherits from both `Base1` and `Base2`. Note that `Base1` does
+not define a simple accessor like `t1` using `typing_arg`, while `Base2` does. This
+is not a problem and can be later added by `Something` using `typing_arg` as well.
+
+You may encounter issues using the `typing_arg` function when using type validator
+like mypy or your IDE. If so you might need to use `cast` to tell the type checker
+you are sure about what you are doing. For example:
+
+```python
+T1 = TypeVar("T1", bound="SomeBaseClass")
+
+
+class Something(
+    GenericArgumentsMixin,
+    Generic[T1],
+):
+    t1 = cast(type[SomeBaseClass], typing_arg(T1))
+```
+
+**Note:** You will still need to use `ClassVar` when using pydantic models. This
+might result in using the same type twice (inside `ClassVar` and `cast`).

typing_arguments-0.1.0/README.md

@@ -0,0 +1,127 @@
+# `typing-arguments`
+
+Typing arguments using the `Generic` base class in python are great, but they lack the ability to
+easily access the type arguments at runtime. This library provides a mixin class that can be used
+to make type arguments available in the class and its instances.
+
+This is also true for classes based on `pydantic.BaseModel` for pydantic > 2.x.
+
+## Installation
+
+Just use `pip install typing-arguments` to install the library.
+
+**Note:** `typing-arguments` is tested on Python `3.10`, `3.11`, `3.12` and `3.13`. This is also ensured running
+all tests on all those versions using `tox`.
+
+## Usage
+
+### Quick Example
+
+```python
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", bound="SomeBaseClass")
+
+
+class Something(
+    GenericArgumentsMixin,
+    Generic[T1, T2],
+):
+    t1 = typing_arg(T1)
+    t2 = typing_arg(T2)
+
+
+ConcreteClass = Something[str, SomeBaseClassChild]
+ConcreteClass.t1  # str
+ConcreteClass.t2  # SomeBaseClassChild
+```
+
+**Hint:** You may also use this with pydantic models:
+
+```python
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", bound="SomeBaseClass")
+
+
+class SomethingModel(
+    GenericArgumentsMixin,
+    BaseModel,
+    Generic[T1, T2],
+):
+    t1: ClassVar = typing_arg(T1)
+    t2: ClassVar = typing_arg(T2)
+
+
+ConcreteClassModel = SomethingModel[str, SomeBaseClassChild]
+ConcreteClassModel.t1  # str
+ConcreteClassModel.t2  # SomeBaseClassChild
+```
+
+Internally `GenericArgumentsMixin` will create a new attribute `__typing_arguments__`
+inside the class and its instances. This attribute is a dictionary mapping the type
+variables to their concrete types. This is useful if you want to access the type
+arguments in a generic way.
+
+The `typing_arg` function is a helper function to make the type arguments available
+in the class and its instances using a nicely named attribute. This is just a
+convenience function, as you can also access the type arguments directly from the
+`__typing_arguments__` attribute.
+
+**Note:** If you are using pydantic models you should use the `ClassVar` annotation
+to ensure pydantic will not try to catch and validate the type arguments as normal
+model fields.
+
+You may also mix different generic base classes like so:
+
+```python
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", bound="SomeBaseClass")
+
+
+class Base1(
+    GenericArgumentsMixin,
+    Generic[T1],
+):
+    pass
+
+
+class Base2(
+    GenericArgumentsMixin,
+    Generic[T2],
+):
+    t2 = typing_arg(T2)
+
+
+class Something(
+    Base1[str],
+    Base2[SomeBaseClassChild],
+):
+    t1 = typing_arg(T1)
+
+
+Something.t1  # str
+Something.t2  # SomeBaseClassChild
+```
+
+In this example `Base1` and `Base2` are both generic base classes. `Base1` only
+defines a type argument `T1` and `Base2` only defines a type argument `T2`. The
+`Something` class inherits from both `Base1` and `Base2`. Note that `Base1` does
+not define a simple accessor like `t1` using `typing_arg`, while `Base2` does. This
+is not a problem and can be later added by `Something` using `typing_arg` as well.
+
+You may encounter issues using the `typing_arg` function when using type validator
+like mypy or your IDE. If so you might need to use `cast` to tell the type checker
+you are sure about what you are doing. For example:
+
+```python
+T1 = TypeVar("T1", bound="SomeBaseClass")
+
+
+class Something(
+    GenericArgumentsMixin,
+    Generic[T1],
+):
+    t1 = cast(type[SomeBaseClass], typing_arg(T1))
+```
+
+**Note:** You will still need to use `ClassVar` when using pydantic models. This
+might result in using the same type twice (inside `ClassVar` and `cast`).

typing_arguments-0.1.0/commitlint.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+    // See https://github.com/conventional-changelog/commitlint/blob/master/%40commitlint/config-conventional/index.js
+    extends: ['@commitlint/config-conventional'],
+    // Own rules
+    rules: {
+        'subject-case': [
+            2,
+            'never',
+            ['start-case', 'pascal-case', 'upper-case'],
+        ],
+    },
+}

typing_arguments-0.1.0/justfile

@@ -0,0 +1,46 @@
+default:
+    just --list
+
+[unix]
+_install-pre-commit:
+    #!/usr/bin/env bash
+    if ( which pre-commit > /dev/null 2>&1 )
+    then
+        pre-commit install --install-hooks
+    else
+        echo "-----------------------------------------------------------------"
+        echo "pre-commit is not installed - cannot enable pre-commit hooks!"
+        echo "Recommendation: Install pre-commit ('brew install pre-commit')."
+        echo "-----------------------------------------------------------------"
+    fi
+
+[windows]
+_install-pre-commit:
+    #!powershell.exe
+    Write-Host "Please ensure pre-commit hooks are installed using 'pre-commit install --install-hooks'"
+
+install: (uv "sync") && _install-pre-commit
+
+update: (uv "sync")
+
+uv *args:
+    uv {{args}}
+
+test *args: (uv "run" "pytest" "--cov=typing_arguments" "--cov-report" "term-missing:skip-covered" args)
+
+test-all: (uv "run" "tox")
+
+ruff *args: (uv "run" "ruff" "check" "typing_arguments" "tests" args)
+
+pyright *args: (uv "run" "pyright" "typing_arguments" args)
+
+lint: ruff pyright
+
+publish: (uv "publish" "--build")
+
+release version: (uv "run" "pkg-version.py" version)
+    git add pyproject.toml
+    git commit -m "release: 🔖 v$(uv run --quiet pkg-version.py)" --no-verify
+    git tag "v$(uv run --quiet pkg-version.py)"
+    git push
+    git push --tags

typing_arguments-0.1.0/nurfile

@@ -0,0 +1,50 @@
+# FILE GENERATED BY nurify COMMAND
+
+def --wrapped "nur _install-pre-commit" [...args] {
+    ^just "_install-pre-commit" ...$args
+}
+
+def --wrapped "nur default" [...args] {
+    ^just "default" ...$args
+}
+
+def --wrapped "nur install" [...args] {
+    ^just "install" ...$args
+}
+
+def --wrapped "nur lint" [...args] {
+    ^just "lint" ...$args
+}
+
+def --wrapped "nur publish" [...args] {
+    ^just "publish" ...$args
+}
+
+def --wrapped "nur pyright" [...args] {
+    ^just "pyright" ...$args
+}
+
+def --wrapped "nur release" [...args] {
+    ^just "release" ...$args
+}
+
+def --wrapped "nur ruff" [...args] {
+    ^just "ruff" ...$args
+}
+
+def --wrapped "nur test" [...args] {
+    ^just "test" ...$args
+}
+
+def --wrapped "nur test-all" [...args] {
+    ^just "test-all" ...$args
+}
+
+def --wrapped "nur update" [...args] {
+    ^just "update" ...$args
+}
+
+def --wrapped "nur uv" [...args] {
+    ^just "uv" ...$args
+}
+

typing_arguments-0.1.0/pkg-version.py

@@ -0,0 +1,24 @@
+import sys
+
+import tomlkit
+
+if __name__ == "__main__":
+    if len(sys.argv) not in (1, 2):
+        raise RuntimeError("Usage: python pkg-version.py [version]")
+
+    if len(sys.argv) == 2:
+        version = sys.argv[1]
+
+        with open("pyproject.toml", "rb") as f:
+            pyproject_toml = tomlkit.parse(f.read())
+
+        pyproject_toml["project"]["version"] = version
+
+        with open("pyproject.toml", "w") as f:
+            f.write(tomlkit.dumps(pyproject_toml))
+    else:
+        with open("pyproject.toml", "rb") as f:
+            pyproject_toml = tomlkit.parse(f.read())
+
+        version = pyproject_toml["project"]["version"]
+        print(version)

typing_arguments-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "typing-arguments"
+version = "0.1.0"
+description = "Store references of your typing arguments to be available at runtime."
+readme = "README.md"
+authors = [
+    {name = "TEAM23 GmbH", email = "info@team23.de"},
+]
+license = {file = "LICENSE"}
+requires-python = ">=3.10"
+dependencies = []
+
+[project.urls]
+Repository = "https://github.com/team23/typing-arguments"
+
+[project.optional-dependencies]
+pydantic = [
+    "pydantic>=2.0.0,<3.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "pydantic>=2.10.1",
+    "pyright>=1.1.389",
+    "pytest>=8.3.3",
+    "pytest-cov>=6.0.0",
+    "ruff>=0.8.0",
+    "tox>=4.23.2",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

typing_arguments-0.1.0/tests/test_generic_arguments.py

@@ -0,0 +1,161 @@
+from typing import ClassVar, Generic, TypeVar
+
+import pytest
+from pydantic import BaseModel
+
+from typing_arguments import GenericArgumentsMixin, typing_arg
+
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+
+
+class PlainGeneric(GenericArgumentsMixin, Generic[T1, T2]):
+    t1 = typing_arg(T1)
+    t2 = typing_arg(T2)
+
+
+class PlainGenericChild(PlainGeneric[str, int]):
+    pass
+
+
+class PlainGenericGrandChild(PlainGenericChild):
+    pass
+
+
+def test_plain_generic():
+    type_alias = PlainGeneric[str, int]
+
+    assert type_alias.__typing_arguments__ == {T1: str, T2: int}
+    assert type_alias.t1 is str
+    assert type_alias.t2 is int
+    assert type_alias().t1 is str
+    assert type_alias().t2 is int
+
+
+def test_plain_generic_raises_exception_if_not_typed():
+    assert PlainGeneric.__typing_arguments__ == {}
+    with pytest.raises(TypeError):
+        PlainGeneric.t1
+    with pytest.raises(TypeError):
+        PlainGeneric.t2
+    with pytest.raises(TypeError):
+        PlainGeneric().t1
+    with pytest.raises(TypeError):
+        PlainGeneric().t2
+
+
+def test_plain_generic_raises_exception_if_base_class_is_not_generic():
+    class NotGeneric(GenericArgumentsMixin):
+        pass
+
+    with pytest.raises(TypeError):
+        NotGeneric[str, int]
+
+
+def test_plain_generic_raises_exception_if_you_try_to_pass_typevars_to_mixin():
+    with pytest.raises(TypeError):
+        class TypeVarsPassedToMixin(
+            GenericArgumentsMixin[T1, T2],
+            Generic[T1, T2],
+        ):
+            pass
+
+
+def test_plain_generic_raises_exception_if_you_miss_generic_base_class():
+    class GenericWithoutBase(
+        GenericArgumentsMixin,
+    ):
+        pass
+
+    with pytest.raises(TypeError):
+        GenericWithoutBase[str, int]
+
+
+def test_plain_generic_raises_exception_if_wrong_arguments_count():
+    with pytest.raises(TypeError):
+        PlainGeneric[str]
+    with pytest.raises(TypeError):
+        PlainGeneric[str, int, str]
+
+
+def test_plain_generic_raises_exception_if_using_typing_arg_on_non_mixin_class():
+    class Something(Generic[T1]):
+        t1 = typing_arg(T1)
+
+    with pytest.raises(TypeError):
+        Something[str].t1
+
+
+def test_plain_generic_child():
+    assert PlainGenericChild.__typing_arguments__ == {T1: str, T2: int}
+    assert PlainGenericChild.t1 is str
+    assert PlainGenericChild.t2 is int
+    assert PlainGenericChild().t1 is str
+    assert PlainGenericChild().t2 is int
+
+
+def test_plain_generic__grand_child():
+    assert PlainGenericGrandChild.__typing_arguments__ == {T1: str, T2: int}
+    assert PlainGenericGrandChild.t1 is str
+    assert PlainGenericGrandChild.t2 is int
+    assert PlainGenericGrandChild().t1 is str
+    assert PlainGenericGrandChild().t2 is int
+
+
+class PydanticModel(GenericArgumentsMixin, BaseModel, Generic[T1, T2]):
+    t1: ClassVar = typing_arg(T1)
+    t2: ClassVar = typing_arg(T2)
+
+
+class PydanticModelChild(PydanticModel[str, int]):
+    pass
+
+
+def test_pydantic_model():
+    type_alias = PydanticModel[str, int]
+
+    assert type_alias.__typing_arguments__ == {T1: str, T2: int}
+    assert type_alias.t1 is str
+    assert type_alias.t2 is int
+    assert type_alias().t1 is str
+    assert type_alias().t2 is int
+
+
+def test_pydantic_model_child():
+    assert PydanticModelChild.__typing_arguments__ == {T1: str, T2: int}
+    assert PydanticModelChild.t1 is str
+    assert PydanticModelChild.t2 is int
+    assert PydanticModelChild().t1 is str
+    assert PydanticModelChild().t2 is int
+
+
+class Base1(GenericArgumentsMixin, Generic[T1]):
+    t1 = typing_arg(T1)
+
+
+class Base2(GenericArgumentsMixin, Generic[T2]):
+    pass
+
+
+class MultiBaseGeneric(Base1[str], Base2[int]):
+    t2 = typing_arg(T2)
+
+
+class MultiBaseGenericChild(MultiBaseGeneric):
+    pass
+
+
+def test_multi_base():
+    assert MultiBaseGeneric.__typing_arguments__ == {T1: str, T2: int}
+    assert MultiBaseGeneric.t1 is str
+    assert MultiBaseGeneric.t2 is int
+    assert MultiBaseGeneric().t1 is str
+    assert MultiBaseGeneric().t2 is int
+
+
+def test_multi_base_child():
+    assert MultiBaseGenericChild.__typing_arguments__ == {T1: str, T2: int}
+    assert MultiBaseGenericChild.t1 is str
+    assert MultiBaseGenericChild.t2 is int
+    assert MultiBaseGenericChild().t1 is str
+    assert MultiBaseGenericChild().t2 is int

typing_arguments-0.1.0/tox.ini

@@ -0,0 +1,13 @@
+[tox]
+isolated_build = True
+envlist =
+    py310,
+    py311,
+    py312,
+    py313
+
+[testenv]
+deps =
+    pytest
+    pydantic
+commands = pytest

typing_arguments-0.1.0/typing-arguments.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.13 (python-libs:typing-arguments)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

typing_arguments-0.1.0/typing_arguments/__init__.py

@@ -0,0 +1,4 @@
+from typing_arguments.generic_arguments import (
+    GenericArgumentsMixin as GenericArgumentsMixin,
+    typing_arg as typing_arg,
+)

typing_arguments-0.1.0/typing_arguments/generic_arguments.py

@@ -0,0 +1,235 @@
+"""
+Generic method to make type arguments of generic models available in the class.
+
+Example:
+-------
+```python
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", bound="SomeBaseClass")
+
+
+class Something(
+    GenericArgumentsMixin,
+    Generic[T1, T2],
+):
+    t1 = typing_arg(T1)
+    t2 = typing_arg(T2)
+
+
+ConcreteClass = Something[str, SomeBaseClassChild]
+ConcreteClass.t1  # str
+ConcreteClass.t2  # SomeBaseClassChild
+```
+
+You may also use this with pydantic models:
+```python
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", bound="SomeBaseClass")
+
+
+class SomethingModel(
+    GenericArgumentsMixin,
+    BaseModel,
+    Generic[T1, T2],
+):
+    t1: ClassVar = typing_arg(T1)
+    t2: ClassVar = typing_arg(T2)
+
+
+ConcreteClassModel = SomethingModel[str, SomeBaseClassChild]
+ConcreteClassModel.t1  # str
+ConcreteClassModel.t2  # SomeBaseClassChild
+```
+
+Internally `GenericArgumentsMixin` will create a new attribute `__typing_arguments__`
+inside the class and its instances. This attribute is a dictionary mapping the type
+variables to their concrete types. This is useful if you want to access the type
+arguments in a generic way.
+
+The `typing_arg` function is a helper function to make the type arguments available
+in the class and its instances using a nicely named attribute. This is just a
+convenience function, as you can also access the type arguments directly from the
+`__typing_arguments__` attribute.
+
+**Note:** If you are using pydantic models you should use the `ClassVar` annotation
+to ensure pydantic will not try to catch and validate the type arguments as normal
+model fields.
+
+You may also mix different generic base classes like so:
+```python
+T1 = TypeVar("T1")
+T2 = TypeVar("T2", bound="SomeBaseClass")
+
+
+class Base1(
+    GenericArgumentsMixin,
+    Generic[T1],
+):
+    pass
+
+
+class Base2(
+    GenericArgumentsMixin,
+    Generic[T2],
+):
+    t2 = typing_arg(T2)
+
+
+class Something(
+    Base1[str],
+    Base2[SomeBaseClassChild],
+):
+    t1 = typing_arg(T1)
+
+
+Something.t1  # str
+Something.t2  # SomeBaseClassChild
+```
+
+In this example `Base1` and `Base2` are both generic base classes. `Base1` only
+defines a type argument `T1` and `Base2` only defines a type argument `T2`. The
+`Something` class inherits from both `Base1` and `Base2`. Note that `Base1` does
+not define a simple accessor like `t1` using `typing_arg`, while `Base2` does. This
+is not a problem and can be later added by `Something` using `typing_arg` as well.
+
+You may encounter issues using the `typing_arg` function when using type validator
+like mypy or your IDE. If so you might need to use `cast` to tell the type checker
+you are sure about what you are doing. For example:
+```python
+T1 = TypeVar("T1", bound="SomeBaseClass")
+
+
+class Something(
+    GenericArgumentsMixin,
+    Generic[T1],
+):
+    t1 = cast(type[SomeBaseClass], typing_arg(T1))
+```
+
+**Note:** You will still need to use `ClassVar` when using pydantic models. This
+might result in using the same type twice (inside `ClassVar` and `cast`).
+"""
+
+import functools
+import types
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast
+from typing import _GenericAlias as TypingGenericAlias  # pyright: ignore[reportAttributeAccessIssue]
+
+try:
+    from pydantic import BaseModel as _PydanticBaseModel  # pyright: ignore[reportAssignmentType]
+except ImportError:  # pragma: no cover
+    # Provide fake pydantic base model
+    class _PydanticBaseModel:
+        pass
+
+GenericTrackerMixinT = TypeVar("GenericTrackerMixinT")
+
+TYPING_ATTRIBUTE_NAME = "__typing_arguments__"
+
+
+class GenericArgumentsMixin:
+    if TYPE_CHECKING:  # pragma: no cover
+        # Same as TYPING_ATTRIBUTE_NAME
+        __typing_arguments__: dict[TypeVar, type[Any]]
+
+    @classmethod
+    @functools.lru_cache(maxsize=None, typed=True)
+    def __class_getitem__(
+        cls: type[GenericTrackerMixinT],
+        params: type[Any] | tuple[type[Any], ...],
+    ) -> type[Any]:
+        if (
+            cls is GenericArgumentsMixin
+            and params
+        ):
+            raise TypeError(
+                'Type parameters should be placed on typing.Generic, '
+                'not GenericArgumentsMixin',
+            )
+        if Generic not in cls.__bases__:
+            raise TypeError(
+                'Cannot provide type arguments to a non-generic class, must '
+                'inherit from typing.Generic first',
+            )
+        if not isinstance(params, tuple):
+            params = (params,)
+
+        base_cls = cls
+        if issubclass(cls, _PydanticBaseModel):
+            base_cls = super().__class_getitem__(params)  # pyright: ignore[reportAttributeAccessIssue]
+
+        if len(cls.__parameters__) != len(params):  # pyright: ignore[reportAttributeAccessIssue]
+            raise TypeError(
+                f'Type {cls.__name__} expects {len(cls.__parameters__)} '  # pyright: ignore[reportAttributeAccessIssue]
+                f'parameters, got {len(params)}',
+            )
+
+        typing_args = dict(zip(cls.__parameters__, params, strict=True))  # pyright: ignore[reportAttributeAccessIssue]
+        if hasattr(cls, TYPING_ATTRIBUTE_NAME):
+            typing_args = {
+                **getattr(cls, TYPING_ATTRIBUTE_NAME),
+                **typing_args,
+            }
+
+        typed_cls = cast(
+            type[GenericArgumentsMixin],
+            types.new_class(
+                f"Typed{cls.__name__}",
+                (base_cls,),
+                {},
+                lambda ns: ns.update({TYPING_ATTRIBUTE_NAME: typing_args}),
+            ),
+        )
+
+        if issubclass(cls, _PydanticBaseModel):
+            return typed_cls
+
+        typed_alias = TypingGenericAlias(typed_cls, params)
+        setattr(typed_alias, TYPING_ATTRIBUTE_NAME, typing_args)
+        return typed_alias
+
+    def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None:
+        super().__init_subclass__(*args, **kwargs)
+
+        if not hasattr(cls, TYPING_ATTRIBUTE_NAME):
+            setattr(cls, TYPING_ATTRIBUTE_NAME, {})
+
+        base_typing_args = {}
+        typing_args = getattr(cls, TYPING_ATTRIBUTE_NAME)
+        for base in reversed(cls.__bases__):
+            if hasattr(base, TYPING_ATTRIBUTE_NAME):
+                base_typing_args.update(getattr(base, TYPING_ATTRIBUTE_NAME))
+
+        setattr(
+            cls, TYPING_ATTRIBUTE_NAME, {
+                **base_typing_args,
+                **typing_args,
+            },
+        )
+
+
+class typing_arg:  # noqa
+    __slots__ = ("type_argument",)
+
+    def __init__(self, type_argument: TypeVar, /) -> None:
+        self.type_argument = type_argument
+
+    def __get__(
+        self,
+        obj: GenericArgumentsMixin,
+        obj_class: type[GenericArgumentsMixin] | None = None,
+    ) -> type[Any]:
+        if obj_class is None:  # pragma: no cover
+            obj_class = obj.__class__
+
+        if not hasattr(obj_class, TYPING_ATTRIBUTE_NAME):
+            raise TypeError(
+                f"{obj_class} seems not be be using GenericArgumentsMixin or "
+                f"no arguments were provided",
+            )
+        if self.type_argument not in getattr(obj_class, TYPING_ATTRIBUTE_NAME):
+            raise TypeError(
+                f"Type argument {self.type_argument} not found in {obj_class}",
+            )
+
+        return getattr(obj_class, TYPING_ATTRIBUTE_NAME)[self.type_argument]