alpha-python 0.1.0__tar.gz → 0.2.1__tar.gz

{alpha_python-0.1.0/src/alpha_python.egg-info → alpha_python-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpha-python
-Version: 0.1.0
+Version: 0.2.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
@@ -15,6 +15,27 @@ 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; 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_python-0.1.0 → alpha_python-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alpha-python"
-version = "0.1.0"
+version = "0.2.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 = [
@@ -17,6 +17,26 @@ dependencies = [
     "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]
@@ -32,6 +52,36 @@ dev = [
     "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",
+    "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]

alpha_python-0.2.1/src/alpha/__init__.py

@@ -0,0 +1,14 @@
+import os
+
+from alpha.containers.container import Container
+
+
+def init_container() -> Container:
+    """Initialize the alpha package container."""
+    CONFIG_PATH = os.getenv("CONFIG_PATH", "./config.yaml")
+
+    container = Container()
+    container.config.from_yaml(CONFIG_PATH)
+
+    container.wire(modules=[__name__])
+    return container

alpha_python-0.2.1/src/alpha/cli.py

@@ -0,0 +1,147 @@
+import argparse
+import os
+import sys
+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 | None:
+    """Guess the name of the package where you are generating the API for,
+    finding the first (and only) folder in the 'src'-folder.
+
+    Returns
+    -------
+    str
+        _description_
+    """
+    cwd = os.getcwd()
+    package_location = f'{cwd}/src'
+    if not os.path.isdir(package_location):
+        return 'None'
+    package_names = [
+        name
+        for name in os.listdir(package_location)
+        if os.path.isdir(os.path.join(package_location, name))
+        and not name.startswith('.')
+        and not name.endswith('.egg-info')
+    ]
+    if len(package_names) == 0:
+        return None
+    return package_names[0]
+
+
+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()

alpha_python-0.2.1/src/alpha/containers/container.py

@@ -0,0 +1,190 @@
+from dependency_injector import containers, providers
+
+from alpha.handlers.api_generate_handler import ApiGenerateHandler
+from alpha.handlers.api_run_handler import ApiRunHandler
+from alpha.handlers.models.command import Command
+from alpha.handlers.models.section import Section
+from alpha.handlers.models.argument import Argument
+
+
+class Container(containers.DeclarativeContainer):
+    """Dependency injection container for the alpha package."""
+
+    config = providers.Configuration()
+
+    api_gen_command = providers.Factory(
+        Command,
+        name='gen',
+        help=(
+            "Generate the API code and watch OpenAPI spec file. The API code "
+            "will be generated into the ./api folder."
+        ),
+        handler=providers.Factory(ApiGenerateHandler),
+        arguments=providers.List(
+            providers.Factory(
+                Argument,
+                default='specification/openapi.yaml',
+                name='--spec-file',
+                help='Path to the specification file',
+                args={
+                    'type': str,
+                    'nargs': '?',
+                },
+            ),
+            providers.Factory(
+                Argument,
+                default=config.api_package_name,
+                name='--api-package',
+                help=(
+                    "Name of the API package to generate. Automatically "
+                    "determined or guessed. If incorrect, "
+                    "just use this argument."
+                ),
+                args={
+                    'type': str,
+                    'nargs': '?',
+                },
+            ),
+            providers.Factory(
+                Argument,
+                default=config.service_package_name,
+                name='--service-package',
+                help=(
+                    "Name of the service package to use. Automatically "
+                    "determined or guessed. If incorrect, "
+                    "just use this argument."
+                ),
+                args={
+                    'type': str,
+                    'nargs': '?',
+                },
+            ),
+            providers.Factory(
+                Argument,
+                default=config.container_import,
+                name='--container-import',
+                help=(
+                    "Name of the container to use. Automatically "
+                    "determined or guessed. If incorrect, "
+                    "just use this argument. When no container is used, "
+                    "use empty string for this variable"
+                ),
+                args={
+                    'type': str,
+                    'nargs': '?',
+                },
+            ),
+            providers.Factory(
+                Argument,
+                default=config.init_container_from,
+                name='--init-container-from',
+                help=(
+                    "Location of where the container initialize function "
+                    "should be imported from."
+                ),
+                args={
+                    'type': str,
+                    'nargs': '?',
+                },
+            ),
+            providers.Factory(
+                Argument,
+                default=config.init_container_function,
+                name='--init-container-function',
+                help="Name of the container initialize function.",
+                args={
+                    'type': str,
+                    'nargs': '?',
+                },
+            ),
+            providers.Factory(
+                Argument,
+                default='post_process.py',
+                name='--post-process-file',
+                help="Path to the post process file to use after generation",
+                args={
+                    'type': str,
+                    'nargs': '?',
+                },
+            ),
+            providers.Factory(
+                Argument,
+                default='python-flask',
+                name='--generator-name',
+                help="Name of the openapi generator to use",
+                args={
+                    'type': str,
+                    'nargs': '?',
+                },
+            ),
+            providers.Factory(
+                Argument,
+                default=False,
+                name='--no-watch',
+                help=(
+                    "To prevent watching the spec file for changes and only "
+                    "run the generation once."
+                ),
+                args={
+                    'action': 'store_true',
+                },
+            ),
+            providers.Factory(
+                Argument,
+                default=False,
+                name='--templates-only',
+                help=(
+                    "Only create a templates folder containing openapi "
+                    "mustache templates in the current working directory. "
+                    "Skip generation of API code."
+                ),
+                args={
+                    'action': 'store_true',
+                },
+            ),
+        ),
+    )
+
+    api_run_command = providers.Factory(
+        Command,
+        name='run',
+        help='Run API in development mode',
+        handler=providers.Factory(ApiRunHandler),
+        arguments=providers.List(
+            providers.Factory(
+                Argument,
+                default=config.api_package_name,
+                name='--api-package',
+                help='Name of the API package to generate',
+                args={
+                    'type': str,
+                    'nargs': '?',
+                },
+            ),
+            providers.Factory(
+                Argument,
+                default='8080',
+                name='--port',
+                help='Port to run server on',
+                args={
+                    'type': str,
+                    'nargs': '?',
+                },
+            ),
+        ),
+    )
+
+    api_section = providers.Factory(
+        Section,
+        name='api',
+        description='OpenAPI development commands.',
+        help=(
+            "All commands for generating and developing an API using the "
+            "OpenAPI standards"
+        ),
+        commands=providers.List(api_gen_command, api_run_command),
+    )
+
+    sections = providers.List(
+        api_section,
+    )

alpha_python-0.2.1/src/alpha/domain/models/__init__.py

@@ -0,0 +1,2 @@
+# from alpha.domain.models.user import User
+# from alpha.domain.models.base_model import BaseDomainModel, DomainModel

alpha_python-0.2.1/src/alpha/domain/models/life_cycle_base.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class LifeCycleBase:
+    created_by: str | None = None
+    created_at: datetime | None = None
+    modified_by: str | None = None
+    modified_at: datetime | None = None

alpha_python-0.2.1/src/alpha/domain/models/user.py

@@ -0,0 +1,66 @@
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Self, Sequence, cast
+from uuid import UUID
+
+from alpha.domain.models.base_model import BaseDomainModel, DomainModel
+from alpha.domain.models.life_cycle_base import LifeCycleBase
+
+from alpha.providers.models.identity import Identity
+
+
+@dataclass(kw_only=True)
+class User(LifeCycleBase, BaseDomainModel):
+    id: UUID | int | str | None = None
+    username: str | None = None
+    password: str | None = None
+    role: str | None = None
+    email: str | None = None
+    phone: str | None = None
+    display_name: str | None = None
+    permissions: Sequence[str] | None = None
+    groups: Sequence[str] | None = None
+    is_active: bool = True
+    admin: bool = False
+
+    @classmethod
+    def from_identity(cls, identity: Identity) -> Self:
+        """Create a User instance from an Identity instance.
+
+        Parameters
+        ----------
+        identity
+            Identity object to convert.
+
+        Returns
+        -------
+            User instance created from the Identity.
+        """
+        return cls(
+            id=identity.subject,
+            username=identity.username,
+            email=identity.email,
+            display_name=identity.display_name,
+        )
+
+    def update(self, obj: DomainModel) -> DomainModel:
+        """Update the User instance with data from another User instance.
+
+        Parameters
+        ----------
+        user
+            User object to update from.
+        """
+        if not isinstance(obj, User):
+            raise TypeError("User.update expects a User instance.")
+
+        self.username = obj.username
+        self.email = obj.email
+        self.phone = obj.phone
+        self.display_name = obj.display_name
+        self.permissions = obj.permissions
+        self.groups = obj.groups
+        self.updated_at = datetime.now(tz=timezone.utc)
+        self.is_active = obj.is_active
+        self.admin = obj.admin
+        return cast(DomainModel, self)