alpha-python 0.3.1__tar.gz

alpha_python-0.3.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 breijling
+
+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.

alpha_python-0.3.1/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: alpha-python
+Version: 0.3.1
+Summary: Alpha is intended to be the first dependency you need to add to your Python application. It is a Python library which contains standard building blocks that can be used in applications that are used as APIs and/or make use of database interaction.
+Author-email: Bart Reijling <bart@reijling.eu>
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: attrs>=25.4.0
+Requires-Dist: gunicorn>=23.0.0
+Requires-Dist: jsonpatch>=1.33
+Requires-Dist: numpy>=2.3.5
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pyjwt>=2.10.1
+Requires-Dist: six>=1.17.0
+Requires-Dist: sqlalchemy>=2.0.44
+Requires-Dist: requests>=2.28.1
+Requires-Dist: dependency-injector<5.0.0,>=4.48.3
+Provides-Extra: api-generator
+Requires-Dist: openapi-generator-cli==7.14.0; (python_version >= "3.11" and python_version < "4.0") and extra == "api-generator"
+Requires-Dist: jdk4py; extra == "api-generator"
+Provides-Extra: flask
+Requires-Dist: connexion[swagger-ui]<3,>=2.14.2; extra == "flask"
+Requires-Dist: swagger-ui-bundle>=0.0.2; extra == "flask"
+Requires-Dist: python_dateutil>=2.6.0; extra == "flask"
+Requires-Dist: itsdangerous==1.1.0; extra == "flask"
+Requires-Dist: MarkupSafe<2.0.2; extra == "flask"
+Requires-Dist: Jinja2==2.11.2; extra == "flask"
+Requires-Dist: Flask<2,>=1.1.2; extra == "flask"
+Requires-Dist: flask-cors>=3.0.10; extra == "flask"
+Requires-Dist: Flask-Compress>=1.13; extra == "flask"
+Provides-Extra: mysql
+Requires-Dist: pymysql>=1.1.2; extra == "mysql"
+Provides-Extra: postgresql
+Requires-Dist: psycopg2-binary>=2.9.11; extra == "postgresql"
+Provides-Extra: ldap
+Requires-Dist: ldap3>=2.9.1; extra == "ldap"
+Dynamic: license-file
+
+# alpha
+
+Alpha is intended to be the first dependency you need to add to your Python application. It is a Python library which contains standard building blocks that can be used in applications that are used as APIs and/or make use of database interaction. 

alpha_python-0.3.1/README.md

@@ -0,0 +1,3 @@
+# alpha
+
+Alpha is intended to be the first dependency you need to add to your Python application. It is a Python library which contains standard building blocks that can be used in applications that are used as APIs and/or make use of database interaction. 

alpha_python-0.3.1/pyproject.toml

@@ -0,0 +1,119 @@
+[project]
+name = "alpha-python"
+version = "0.3.1"
+description = "Alpha is intended to be the first dependency you need to add to your Python application. It is a Python library which contains standard building blocks that can be used in applications that are used as APIs and/or make use of database interaction."
+readme = "README.md"
+authors = [
+    { name = "Bart Reijling", email = "bart@reijling.eu" }
+]
+requires-python = ">=3.11"
+dependencies = [
+    "attrs>=25.4.0",
+    "gunicorn>=23.0.0",
+    "jsonpatch>=1.33",
+    "numpy>=2.3.5",
+    "pandas>=2.3.3",
+    "pydantic>=2.12.5",
+    "pyjwt>=2.10.1",
+    "six>=1.17.0",
+    "sqlalchemy>=2.0.44",
+    "requests>=2.28.1",
+    "dependency-injector (>=4.48.3,<5.0.0)",
+]
+
+[project.scripts]
+alpha = "alpha.cli:init"
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-data]
+"alpha.handlers" = [
+    "**/*.mustache",
+    "*.sh",
+]
+
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[dependency-groups]
+dev = [
+    "black>=25.11.0",
+    "coverage>=7.12.0",
+    "isort>=7.0.0",
+    "mypy>=1.18.2",
+    "pytest>=9.0.1",
+    "pytest-cov>=7.0.0",
+    "ruff>=0.14.7",
+    "psycopg2-binary>=2.9.11",
+    "pymysql>=1.1.2",
+    "ldap3>=2.9.1",
+    "cryptography>=46.0.3"
+]
+
+[project.optional-dependencies]
+api-generator = [
+    "openapi-generator-cli==7.14.0 ; python_version >= '3.11' and python_version < '4.0'",
+    "jdk4py"
+]
+flask = [
+    "connexion[swagger-ui]>=2.14.2,<3",
+    "swagger-ui-bundle>=0.0.2",
+    "python_dateutil>=2.6.0",
+    "itsdangerous==1.1.0",
+    "MarkupSafe<2.0.2",
+    "Jinja2==2.11.2",
+    "Flask>=1.1.2,<2",
+    "flask-cors>=3.0.10",
+    "Flask-Compress>=1.13",
+]
+mysql = [
+    "pymysql>=1.1.2"
+]
+postgresql = [
+    "psycopg2-binary>=2.9.11"
+]
+ldap = [
+    "ldap3>=2.9.1"
+]
+
+[tool.pytest.ini_options]
+minversion = 7.0
+python_files = "test_*.py"
+addopts = "-v -p no:warnings --cov --cov-report=lcov:./coverage/lcov.info --cov-report=term --cov-report=term-missing"
+testpaths = [
+    "tests"
+]
+
+[tool.coverage.run]
+source = ["src"]
+omit = [
+    "tests/*",
+    "__init__.py",
+    "_http_codes.py"
+]
+
+[tool.black]
+line-length = 79
+skip-string-normalization = true
+target-version = ['py310', 'py311', 'py312', 'py313']
+
+[tool.isort]
+py_version = 311
+profile = "black"
+line_length = 79
+force_grid_wrap = 0
+
+[tool.mypy]
+python_version = "3.11"
+exclude = ['^tests/']
+
+[tool.ruff]
+line-length = 79

alpha_python-0.3.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

alpha_python-0.3.1/src/alpha/__init__.py

@@ -0,0 +1,125 @@
+from alpha.adapters.sqla_unit_of_work import SqlAlchemyUnitOfWork
+from alpha.factories.jwt_factory import JWTFactory
+from alpha.factories.logging_handler_factory import LoggingHandlerFactory
+from alpha.factories.model_class_factory import ModelClassFactory
+from alpha.domain.models.user import User
+from alpha.domain.models.base_model import BaseDomainModel, DomainModel
+from alpha.domain.models.life_cycle_base import LifeCycleBase
+from alpha.infra.connectors.ldap_connector import LDAPConnector
+from alpha.infra.connectors.oidc_connector import (
+    OIDCConnector,
+    KeyCloakOIDCConnector,
+)
+from alpha.infra.databases.sql_alchemy import SqlAlchemyDatabase
+from alpha.infra.models.filter_operators import And, Or
+from alpha.infra.models.json_patch import JsonPatch
+from alpha.infra.models.order_by import OrderBy, Order
+from alpha.infra.models.search_filter import SearchFilter, Operator
+from alpha.interfaces.attrs_instance import AttrsInstance
+from alpha.interfaces.dataclass_instance import DataclassInstance
+from alpha.interfaces.pydantic_instance import PydanticInstance
+from alpha.interfaces.openapi_model import OpenAPIModel
+from alpha.interfaces.updateable import Updateable
+from alpha.interfaces.patchable import Patchable
+from alpha.interfaces.sql_repository import SqlRepository
+from alpha.interfaces.sql_mapper import SqlMapper
+from alpha.interfaces.sql_database import SqlDatabase
+from alpha.interfaces.unit_of_work import UnitOfWork
+from alpha.interfaces.providers import (
+    IdentityProvider,
+    PasswordAuthenticator,
+    UserDirectory,
+    PasswordChanger,
+    TokenIssuer,
+    TokenValidator,
+)
+from alpha.interfaces.token_factory import TokenFactory
+from alpha.mixins.jwt_provider import JWTProviderMixin
+from alpha.providers.models.identity import (
+    Identity,
+    DEFAULT_LDAP_MAPPINGS,
+    DEFAULT_AD_MAPPINGS,
+    AD_SEARCH_ATTRIBUTES,
+)
+from alpha.providers.models.credentials import PasswordCredentials
+from alpha.providers.models.token import Token
+from alpha.providers.ldap_provider import LDAPProvider, ADProvider
+from alpha.providers.oidc_provider import OIDCProvider, KeyCloakProvider
+from alpha.repositories.models.repository_model import RepositoryModel
+from alpha.repositories.sql_alchemy_repository import SqlAlchemyRepository
+from alpha.services.authentication_service import AuthenticationService
+from alpha.utils.is_attrs import is_attrs
+from alpha.utils.is_pydantic import is_pydantic
+from alpha.utils.logging_configurator import (
+    LoggingConfigurator,
+    GunicornLogger,
+)
+from alpha.utils.logging_level_checker import logging_level_checker
+from alpha.utils.response_object import create_response_object
+from alpha.utils.verify_identity import verify_identity
+from alpha.utils.version_checker import minor_version_gte
+
+
+from alpha.encoder import JSONEncoder
+
+__all__ = [
+    "SqlAlchemyUnitOfWork",
+    "JWTFactory",
+    "LoggingHandlerFactory",
+    "ModelClassFactory",
+    "BaseDomainModel",
+    "DomainModel",
+    "LifeCycleBase",
+    "User",
+    "LDAPConnector",
+    "OIDCConnector",
+    "KeyCloakOIDCConnector",
+    "SqlAlchemyDatabase",
+    "And",
+    "Or",
+    "JsonPatch",
+    "OrderBy",
+    "Order",
+    "SearchFilter",
+    "Operator",
+    "AttrsInstance",
+    "DataclassInstance",
+    "PydanticInstance",
+    "OpenAPIModel",
+    "Updateable",
+    "Patchable",
+    "SqlRepository",
+    "SqlMapper",
+    "SqlDatabase",
+    "UnitOfWork",
+    "IdentityProvider",
+    "PasswordAuthenticator",
+    "TokenValidator",
+    "UserDirectory",
+    "PasswordChanger",
+    "TokenIssuer",
+    "TokenFactory",
+    "JWTProviderMixin",
+    "Identity",
+    "DEFAULT_LDAP_MAPPINGS",
+    "DEFAULT_AD_MAPPINGS",
+    "AD_SEARCH_ATTRIBUTES",
+    "PasswordCredentials",
+    "Token",
+    "LDAPProvider",
+    "ADProvider",
+    "OIDCProvider",
+    "KeyCloakProvider",
+    "RepositoryModel",
+    "SqlAlchemyRepository",
+    "AuthenticationService",
+    "is_attrs",
+    "is_pydantic",
+    "LoggingConfigurator",
+    "GunicornLogger",
+    "logging_level_checker",
+    "create_response_object",
+    "verify_identity",
+    "minor_version_gte",
+    "JSONEncoder",
+]

alpha_python-0.3.1/src/alpha/adapters/__init__.py

@@ -0,0 +1,5 @@
+from alpha.adapters.sqla_unit_of_work import SqlAlchemyUnitOfWork
+
+__all__ = [
+    "SqlAlchemyUnitOfWork",
+]

alpha_python-0.3.1/src/alpha/adapters/sqla_unit_of_work.py

@@ -0,0 +1,120 @@
+"""Contains the SQLAlchemy Unit of Work implementation."""
+
+from typing import Any, TypeVar
+
+from sqlalchemy.orm.session import Session
+
+from alpha import exceptions
+from alpha.interfaces.sql_database import SqlDatabase
+from alpha.repositories.models.repository_model import RepositoryModel
+
+UOW = TypeVar("UOW", bound="SqlAlchemyUnitOfWork")
+
+
+class SqlAlchemyUnitOfWork:
+    """Unit of Work implementation for SQLAlchemy databases."""
+
+    def __init__(self, db: SqlDatabase, repos: list[RepositoryModel]) -> None:
+        """Initialize the Unit of Work with a database and repositories.
+
+        Parameters
+        ----------
+        db : SqlDatabase
+            The database instance to use.
+        repos : list[RepositoryModel]
+            The list of repository models to use.
+
+        Raises
+        ------
+        TypeError
+            If the provided database is not a valid SqlDatabase instance.
+        TypeError
+            If the provided repositories list is empty or contains invalid
+            models.
+        """
+        if not isinstance(db, SqlDatabase):  # type: ignore
+            raise TypeError("No valid database provided")
+
+        self._db = db
+        self._repositories = repos
+        self._session: Session | None = None
+
+    def __enter__(self: UOW) -> UOW:
+        """Initialize the Unit of Work context.
+
+        Returns
+        -------
+            The Unit of Work instance.
+
+        Raises
+        ------
+        TypeError
+            If the provided repositories list is empty or contains invalid
+            models.
+        """
+        self._session = self._db.get_session()
+
+        for repo in self._repositories:
+            session = self._session
+            model = repo.default_model
+
+            name: str = repo.name
+            repository = repo.repository
+            interface: Any = repo.interface
+
+            self.__setattr__(
+                name,
+                repository(session=session, default_model=model),  # type: ignore
+            )
+            if interface:
+                if not isinstance(getattr(self, name), interface):
+                    raise TypeError(f"Repository for {name} has no interface")
+
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        """Finalize the Unit of Work context."""
+        if not self._session:
+            raise exceptions.DatabaseSessionError(
+                "No active database session is defined"
+            )
+        self._session.close()
+        self.rollback()
+        self._session = None  # type: ignore
+
+    def commit(self) -> None:
+        """Commit the current transaction."""
+        if not self._session:
+            raise exceptions.DatabaseSessionError(
+                "No active database session is defined"
+            )
+        self._session.commit()
+
+    def flush(self) -> None:
+        """Flush the current transaction."""
+        if not self._session:
+            raise exceptions.DatabaseSessionError(
+                "No active database session is defined"
+            )
+        self._session.flush()
+
+    def rollback(self) -> None:
+        """Rollback the current transaction."""
+        if not self._session:
+            raise exceptions.DatabaseSessionError(
+                "No active database session is defined"
+            )
+        self._session.rollback()
+
+    def refresh(self, obj: object) -> None:
+        """Refresh the state of a given object."""
+        if not self._session:
+            raise exceptions.DatabaseSessionError(
+                "No active database session is defined"
+            )
+        self._session.refresh(obj)
+
+    @property
+    def session(self) -> Session | None:
+        """Get the current database session."""
+        return self._session

alpha_python-0.3.1/src/alpha/cli.py

@@ -0,0 +1,160 @@
+import argparse
+import os
+import sys
+import tomllib
+from dependency_injector.wiring import Provide, inject
+
+from alpha.containers.container import Container
+from alpha.handlers.models.section import Section
+
+
+@inject
+def main(sections: list[Section] = Provide[Container.sections]) -> None:
+    """Entry point for the alpha cli.
+
+    Parameters
+    ----------
+    sections: List[Section]
+        List of sections to include in the cli.
+    """
+
+    # Create the main parser
+    parser = argparse.ArgumentParser(
+        description='Alpha command line interface.',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    subparsers = parser.add_subparsers(
+        title='Use one of the sub categories to run commands on',
+        dest='section',
+    )
+
+    # Parser dict to store in all parsers to match later on when finding a
+    # handler.
+    section_parsers = {}
+    command_parsers = {}
+
+    # Create all sections
+    for section in sections:
+        command_parsers[section.name] = {}
+        section_parsers[section.name] = subparsers.add_parser(
+            section.name,
+            description=section.description,
+            help=section.help,
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        )
+        section_subparser = section_parsers[section.name].add_subparsers(
+            dest='command'
+        )
+
+        # Create all commands per section
+        for command in section.commands:
+            command_parsers[section.name][command.name] = (
+                section_subparser.add_parser(
+                    command.name,
+                    help=command.help,
+                    formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+                )
+            )
+
+            # Add all arguments for a command
+            for argument in command.arguments:
+                command_parsers[section.name][command.name].add_argument(
+                    argument.name,
+                    help=argument.help,
+                    default=argument.default,
+                    **argument.args,
+                )
+
+    # Do the handling for the given section and command in the CLI
+    section_argument = None
+    command_argument = None
+    args = parser.parse_args()
+
+    try:
+        section_argument = args.section
+        command_argument = args.command
+    except AttributeError:
+        parser.print_help()
+        return
+
+    if not section_argument:
+        # Can not occur, but just in case. Should be handled above
+        return
+
+    if not command_argument:
+        section_parsers[section_argument].print_help()
+        return
+
+    # Get all arguments and remove the section and command so they can be
+    # 'kwarged' into the Handler set_arguments function.
+    handler_args = vars(args)
+    del handler_args['section']
+    del handler_args['command']
+
+    # Find the right handler
+    for section in sections:
+        for command in section.commands:
+            if (
+                section.name == section_argument
+                and command.name == command_argument
+            ):
+                command.handler.set_arguments(**handler_args)
+                command.handler.handle_command()
+                return
+
+    print('No handler found, you should never read this')
+    return
+
+
+def _guess_current_package_name() -> str:
+    """Guess the name of the python package where you are generating the API
+    for. If a pyproject.toml file can be found the name is read from there. If
+    not, it looks for a subfolder which contains a python package.
+
+    Returns
+    -------
+    str
+        The guessed package name.
+    """
+
+    cwd = os.getcwd()
+    pyproject_path = os.path.join(cwd, 'pyproject.toml')
+
+    # look for pyproject.toml file in subfolders
+    if not os.path.isfile(pyproject_path):
+        for entry in os.scandir(cwd):
+            if not entry.is_dir():
+                continue
+            possible_path = os.path.join(entry.path, 'pyproject.toml')
+            if os.path.isfile(possible_path):
+                pyproject_path = possible_path
+                break
+
+    if os.path.isfile(pyproject_path):
+        try:
+            with open(pyproject_path, 'rb') as f:
+                pyproject_data = tomllib.load(f)
+                return pyproject_data['project']['name'].replace('-', '_')
+        except Exception:
+            pass
+
+    # Fallback to use the current folder name
+    print('Could not find pyproject.toml, guessing package name from folder')
+    return os.path.basename(cwd)
+
+
+def init() -> None:
+    """Init the container and wire it to the main function."""
+    container = Container()
+    guessed_name = _guess_current_package_name()
+    if guessed_name:
+        container.config.api_package_name.from_value(f'{guessed_name}_api')
+        container.config.service_package_name.from_value(guessed_name)
+        container.config.container_import.from_value(
+            f'from {guessed_name}.containers.container import Container'
+        )
+        container.config.init_container_from.from_value(guessed_name)
+        container.config.init_container_function.from_value('init_container')
+    container.wire(modules=[sys.modules[__name__]])
+
+    main()