alpha-python 0.6.1__tar.gz → 0.6.3__tar.gz

{alpha_python-0.6.1 → alpha_python-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpha-python
-Version: 0.6.1
+Version: 0.6.3
 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>
 License-Expression: MIT

{alpha_python-0.6.1 → alpha_python-0.6.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alpha-python"
-version = "0.6.1"
+version = "0.6.3"
 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 = [

{alpha_python-0.6.1 → alpha_python-0.6.3}/src/alpha/__init__.py

@@ -20,7 +20,7 @@ from alpha.infra.connectors.oidc_connector import (
     KeyCloakOIDCConnector,
 )
 from alpha.infra.connectors.sql_alchemy import SqlAlchemyDatabase
-from alpha.infra.models.filter_operators import And, Or
+from alpha.infra.models.filter_operators import And, Or, FilterOperator
 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
@@ -116,6 +116,7 @@ __all__ = [
     "SqlAlchemyDatabase",
     "And",
     "Or",
+    "FilterOperator",
     "JsonPatch",
     "OrderBy",
     "Order",

{alpha_python-0.6.1 → alpha_python-0.6.3}/src/alpha/encoder.py

@@ -4,6 +4,7 @@ complex types into JSON format.
 
 import json
 from dataclasses import asdict, is_dataclass
+from attrs import asdict as attrs_asdict
 from datetime import date, datetime, time
 from enum import Enum
 from json import encoder
@@ -14,8 +15,9 @@ import numpy as np  # type: ignore[import-untyped]
 import pandas as pd  # type: ignore[import-untyped]
 import six  # type: ignore[import-untyped]
 
-
 from alpha.interfaces.openapi_model import OpenAPIModel
+from alpha.utils.is_attrs import is_attrs
+from alpha.utils.is_pydantic import is_pydantic
 
 
 class JSONEncoder(encoder.JSONEncoder):
@@ -72,11 +74,15 @@ class JSONEncoder(encoder.JSONEncoder):
             return o.isoformat()
         if isinstance(o, time):
             return o.isoformat()
+        if isinstance(o, type):
+            cls = getattr(o, "__name__", None)
+            return cls if cls is not None else str(o)
         if is_dataclass(o):
-            if isinstance(o, type):
-                cls = getattr(o, "__class__")
-                return cls.__name__
-            return asdict(o)
+            return asdict(o)  # type: ignore
+        if is_attrs(o):
+            return attrs_asdict(o)
+        if is_pydantic(o):
+            return o.model_dump()
 
         try:
             return json.JSONEncoder.default(self, o)

{alpha_python-0.6.1 → alpha_python-0.6.3}/src/alpha/factories/response_factory.py

@@ -3,12 +3,14 @@
 import json
 from dataclasses import MISSING, is_dataclass
 from enum import Enum
-from typing import Any, Iterable, get_args, get_origin
+from typing import Any, Sequence, get_args, get_origin
 
 from alpha import exceptions
 from alpha.encoder import JSONEncoder
+from alpha.interfaces.attrs_instance import AttrsInstance
 from alpha.interfaces.dataclass_instance import DataclassInstance
 from alpha.interfaces.openapi_model import OpenAPIModel
+from alpha.interfaces.pydantic_instance import PydanticInstance
 from alpha.utils.is_attrs import is_attrs
 from alpha.utils.is_pydantic import is_pydantic
 
@@ -18,8 +20,13 @@ class ResponseFactory:
 
     def process(
         self,
-        response: DataclassInstance | Iterable[DataclassInstance],
-        cls: OpenAPIModel | Iterable[OpenAPIModel],
+        response: DataclassInstance
+        | Sequence[DataclassInstance]
+        | AttrsInstance
+        | Sequence[AttrsInstance]
+        | PydanticInstance
+        | Sequence[PydanticInstance],
+        cls: OpenAPIModel | Sequence[OpenAPIModel],
     ) -> object:
         """Mapping a dataclass instance or a collection of instances to an
         OpenAPI model
@@ -54,7 +61,7 @@ class ResponseFactory:
 
         # When the source instance and target class are of an iterable type
         if cls_origin in [list, tuple, set]:
-            if isinstance(response, Iterable):
+            if isinstance(response, Sequence):
                 arg = get_args(cls)[0]
                 return [
                     self.process(response=obj, cls=arg) for obj in response

{alpha_python-0.6.1 → alpha_python-0.6.3}/src/alpha/handlers/templates/python-flask/controller.mustache

@@ -12,6 +12,7 @@ from typing import List
 from alpha.factories.request_factory import RequestFactory
 from alpha.factories.response_factory import ResponseFactory
 from alpha.encoder import JSONEncoder
+from alpha.providers.models.identity import Identity
 from alpha.utils.logging_level_checker import logging_level_checker
 from alpha.utils.response_object import create_response_object
 from alpha.utils.request_headers import Headers
@@ -43,9 +44,7 @@ from {{packageName}} import models as api_models
 
 {{#operations}}
 {{#operation}}
-{{#authMethods}}{{#vendorExtensions.x-alpha-service-name}}@inject{{/vendorExtensions.x-alpha-service-name}}{{/authMethods}}
-{{^authMethods}}{{#vendorExtensions.x-alpha-service-name}}@inject{{/vendorExtensions.x-alpha-service-name}}{{/authMethods}}
-{{#authMethods}}{{^vendorExtensions.x-alpha-service-name}}@inject{{/vendorExtensions.x-alpha-service-name}}{{/authMethods}}
+{{#authMethods}}{{#-first}}@inject{{/-first}}{{/authMethods}}{{^authMethods}}{{#vendorExtensions.x-alpha-service-name}}@inject{{/vendorExtensions.x-alpha-service-name}}{{/authMethods}}
 def {{operationId}}(
     {{#allParams}}{{^isBodyParam}}{{paramName}}{{^required}}=None{{/required}},{{/isBodyParam}}{{/allParams}}
     {{#authMethods}}{{#isBasicBearer}}token_factory=Provide[Container.token_factory],{{/isBasicBearer}}{{/authMethods}}
@@ -229,7 +228,8 @@ def {{operationId}}(
         token_factory.validate(auth_token)
 
         # Get auth token payload and verify identity
-        identity = token_factory.get_payload(auth_token)
+        payload = token_factory.get_payload(auth_token)
+        identity = Identity.from_dict(payload)
         verify_identity(identity,
             roles=roles,
             groups=groups,
@@ -309,8 +309,9 @@ def {{operationId}}(
             status_code={{code}},
             status_message='{{message}}',
             data=result,
-            {{#vendorExtensions.x-content-type}}data_type='{{vendorExtensions.x-content-type}}'{{/vendorExtensions.x-content-type}}
-            {{#vendorExtensions.x-alpha-cookie-support}}response_type='flask'{{/vendorExtensions.x-alpha-cookie-support}}
+            accept_header={{#vendorExtensions.x-content-type}}'{{vendorExtensions.x-content-type}}'{{/vendorExtensions.x-content-type}}{{^vendorExtensions.x-content-type}}connexion.request.headers.get("Accept", None){{/vendorExtensions.x-content-type}},
+            supported_accept_headers=[{{#produces}}'{{mediaType}}',{{/produces}}{{^produces}}{{#vendorExtensions.x-preferred-produce}}'{{mediaType}}',{{/vendorExtensions.x-preferred-produce}}{{/produces}}],
+            {{#vendorExtensions.x-alpha-cookie-support}}response_format='flask'{{/vendorExtensions.x-alpha-cookie-support}}
         )
         {{/returnType}}
         {{^returnType}}
@@ -318,19 +319,20 @@ def {{operationId}}(
             http_codes=http_codes,
             status_code=204,
             status_message='{{message}}',
-            {{#vendorExtensions.x-alpha-cookie-support}}data=result, response_type='flask'{{/vendorExtensions.x-alpha-cookie-support}}
+            {{#vendorExtensions.x-alpha-cookie-support}}data=result, response_format='flask'{{/vendorExtensions.x-alpha-cookie-support}}
         )
         {{/returnType}}
         {{/vendorExtensions.x-alpha-raw-response}}
     {{/is2xx}}
-    
     {{#is4xx}}
         {{#vendorExtensions.x-alpha-exception}}
     except {{vendorExtensions.x-alpha-exception}} as exc:
         return response_object_function(
             http_codes=http_codes,
             status_code={{code}},
-            status_message=f'{exc}'
+            status_message=f'{exc}',
+            accept_header={{#vendorExtensions.x-content-type}}'{{vendorExtensions.x-content-type}}'{{/vendorExtensions.x-content-type}}{{^vendorExtensions.x-content-type}}connexion.request.headers.get("Accept", None){{/vendorExtensions.x-content-type}},
+            supported_accept_headers=[{{#produces}}'{{mediaType}}',{{/produces}}{{^produces}}{{#vendorExtensions.x-preferred-produce}}'{{mediaType}}',{{/vendorExtensions.x-preferred-produce}}{{/produces}}],
         )
         {{/vendorExtensions.x-alpha-exception}}
     {{/is4xx}}
@@ -341,6 +343,8 @@ def {{operationId}}(
             http_codes=http_codes,
             status_code={{code}},
             status_message=f'{exc}'
+            accept_header={{#vendorExtensions.x-content-type}}'{{vendorExtensions.x-content-type}}'{{/vendorExtensions.x-content-type}}{{^vendorExtensions.x-content-type}}connexion.request.headers.get("Accept", None){{/vendorExtensions.x-content-type}},
+            supported_accept_headers=[{{#produces}}'{{mediaType}}',{{/produces}}{{^produces}}{{#vendorExtensions.x-preferred-produce}}'{{mediaType}}',{{/vendorExtensions.x-preferred-produce}}{{/produces}}],
         )
         {{/vendorExtensions.x-alpha-exception}}
     {{/is5xx}}

{alpha_python-0.6.1 → alpha_python-0.6.3}/src/alpha/infra/__init__.py

@@ -3,7 +3,7 @@ from alpha.infra.connectors.oidc_connector import (
     KeyCloakOIDCConnector,
 )
 from alpha.infra.connectors.sql_alchemy import SqlAlchemyDatabase
-from alpha.infra.models.filter_operators import And, Or
+from alpha.infra.models.filter_operators import And, Or, FilterOperator
 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
@@ -22,6 +22,7 @@ __all__ = [
     "SqlAlchemyDatabase",
     "And",
     "Or",
+    "FilterOperator",
     "JsonPatch",
     "OrderBy",
     "Order",

{alpha_python-0.6.1 → alpha_python-0.6.3}/src/alpha/infra/connectors/ldap_connector.py

@@ -31,6 +31,9 @@ class LDAPConnector:
         server_port: int = 636,
         use_tls: bool = True,
         client_strategy: ClientStrategyType = SYNC,
+        connect_timeout: float | None = 5.0,
+        additional_connector_params: dict[str, Any] | None = None,
+        additional_server_params: dict[str, Any] | None = None,
     ) -> None:
         """
         Parameters
@@ -59,12 +62,29 @@ class LDAPConnector:
             - 'MOCK_SYNC': Mock synchronous strategy.
             - 'MOCK_ASYNC': Mock asynchronous strategy.
             - 'ASYNC_STREAM': Asynchronous stream strategy.
+        connect_timeout
+            Maximum number of seconds to wait while opening the socket.
+        additional_connector_params
+            Additional parameters to pass to the LDAP connection, by default
+            {"receive_timeout": 5}
+        additional_server_params
+            Additional parameters to pass to the LDAP server, by default None
         """
         self._server_url = server_url
         self._bind_dn = bind_dn
         self._bind_password = bind_password
         self._client_strategy = client_strategy
-
+        self._connect_timeout = connect_timeout
+        self._additional_connector_params: dict[str, Any] = (
+            {"receive_timeout": 5}
+            if additional_connector_params is None
+            else dict(additional_connector_params)
+        )
+        self._additional_server_params: dict[str, Any] = (
+            {}
+            if additional_server_params is None
+            else dict(additional_server_params)
+        )
         tls = None
         if use_tls:
             tls = Tls(
@@ -78,6 +98,8 @@ class LDAPConnector:
             use_ssl=use_tls,
             tls=tls,
             get_info=ALL,
+            connect_timeout=self._connect_timeout,
+            **self._additional_server_params,
         )
         self._connection: Connection | None = None
 
@@ -97,8 +119,9 @@ class LDAPConnector:
             self._server,
             user=self._bind_dn,
             password=self._bind_password,
-            auto_bind=True,
             client_strategy=self._client_strategy,  # type: ignore
+            auto_bind=True,
+            **self._additional_connector_params,
         )
 
     def disconnect(self) -> None:

{alpha_python-0.6.1 → alpha_python-0.6.3}/src/alpha/infra/models/filter_operators.py

@@ -4,7 +4,7 @@
 - Or
 """
 
-from typing import Any, Callable, Iterable
+from typing import Any, Callable, Iterable, Self
 
 from sqlalchemy.orm import Query
 from sqlalchemy.sql.expression import ColumnElement, and_, or_
@@ -17,13 +17,11 @@ class FilterOperator:
     search query
     """
 
-    def __init__(self, *search_filters: SearchFilter):
+    def __init__(self, *search_filters: SearchFilter | Self) -> None:
         """Instantiate the filter operator by storing the search filter
         objects
         """
-        self.search_filters: Iterable[SearchFilter | FilterOperator] = (
-            search_filters
-        )
+        self.search_filters: Iterable[SearchFilter | Self] = search_filters
 
     @property
     def filter_operator(

{alpha_python-0.6.1 → alpha_python-0.6.3}/src/alpha/interfaces/sql_database.py

@@ -32,5 +32,3 @@ class SqlDatabase(Protocol):
     def drop_tables(
         self, metadata: sa.MetaData, tables: list[sa.Table] | None = None
     ) -> None: ...
-
-    def _create_schema(self, engine: Engine, schema_name: str) -> None: ...

{alpha_python-0.6.1 → alpha_python-0.6.3}/src/alpha/utils/response_object.py

@@ -1,8 +1,8 @@
-from typing import TYPE_CHECKING, Any, Literal, overload
 import json
-from alpha.encoder import JSONEncoder
-from alpha.utils.cookie import Cookie
+from typing import TYPE_CHECKING, Any, Literal, overload
+
 from alpha.utils._http_codes import http_codes_en
+from alpha.utils.cookie import Cookie
 
 if TYPE_CHECKING:
     from flask.wrappers import Response
@@ -15,10 +15,12 @@ def create_response_object(
     status_code: int,
     status_message: str,
     data: Any | None,
-    data_type: str,
+    accept_header: str,
+    supported_accept_headers: list[str] | None,
     http_codes: dict[int, tuple[str, str]],
     json_encoder: type[json.JSONEncoder] | None,
-    response_type: Literal["dict"],
+    response_format: Literal["dict"],
+    **kwargs: Any,
 ) -> tuple[dict[str, Any], int]: ...
 
 
@@ -27,10 +29,12 @@ def create_response_object(
     status_code: int,
     status_message: str,
     data: Any | None,
-    data_type: str,
+    accept_header: str,
+    supported_accept_headers: list[str] | None,
     http_codes: dict[int, tuple[str, str]],
     json_encoder: type[json.JSONEncoder] | None,
-    response_type: Literal["flask"],
+    response_format: Literal["flask"],
+    **kwargs: Any,
 ) -> tuple[Response, int]: ...
 
 
@@ -39,10 +43,12 @@ def create_response_object(
     status_code: int,
     status_message: str,
     data: Any | None,
-    data_type: str,
+    accept_header: str,
+    supported_accept_headers: list[str] | None,
     http_codes: dict[int, tuple[str, str]],
     json_encoder: type[json.JSONEncoder] | None,
-    response_type: None = None,
+    response_format: None = None,
+    **kwargs: Any,
 ) -> tuple[dict[str, Any], int]: ...
 
 
@@ -50,16 +56,20 @@ def create_response_object(
     status_code: int,
     status_message: str,
     data: Any | None = None,
-    data_type: str = "application/json",
+    accept_header: str = "application/json",
+    supported_accept_headers: list[str] | None = None,
     http_codes: dict[int, tuple[str, str]] = http_codes_en,
-    json_encoder: type[json.JSONEncoder] | None = JSONEncoder,
-    response_type: str | None = "dict",
+    json_encoder: type[json.JSONEncoder] | None = None,
+    response_format: str | None = "dict",
+    **kwargs: Any,
 ) -> tuple[Response, int] | tuple[dict[str, Any], int]:
     """Create a HTTP response object.
 
     The response object can be either a dictionary or a Flask Response object,
-    depending on the value of `response_type`. The response will include the
+    depending on the value of `response_format`. The response will include the
     status code, a human-readable message, and optionally additional data.
+    Only supports JSON responses. For other types, use custom function with
+    x-alpha-custom-response-builder in the OpenAPI specification.
 
     Parameters
     ----------
@@ -69,15 +79,18 @@ def create_response_object(
         Human-readable message describing the status.
     data
         Additional data to include in the response, by default None
-    data_type
-        The MIME type of the response, by default "application/json"
+    accept_header
+        The value of the Accept header from the request,
+        by default "application/json"
+    supported_accept_headers
+        A list of supported MIME types for the data_type parameter.
     http_codes
         A dictionary mapping HTTP status codes to their descriptions, by
         default http_codes_en
     json_encoder
         A custom JSON encoder class to use when encoding the response data, by
-        default alpha.encoder.JSONEncoder
-    response_type
+        default None. If None, the default JSONEncoder will be used.
+    response_format
         The type of response to create, either "flask" or "dict", by default
         "dict"
 
@@ -85,13 +98,21 @@ def create_response_object(
     -------
     tuple[dict[str, Any], int]
         A tuple containing the response object as a dictionary and the HTTP
-        status code. When response_type is "dict".
+        status code. When response_format is "dict".
     tuple[Response, int]
         A tuple containing the flask.Response object and the HTTP status code.
-        When response_type is "flask".
+        When response_format is "flask".
     """
-    if response_type is None:
-        response_type = "dict"
+    data_type = _resolve_data_type(accept_header, supported_accept_headers)
+
+    if response_format is None:
+        response_format = "dict"
+
+    if json_encoder is None:
+        # Lazily import to avoid circular import during alpha package init.
+        from alpha.encoder import JSONEncoder
+
+        json_encoder = JSONEncoder
 
     obj: dict[str, Any] = {
         "detail": status_message,
@@ -100,7 +121,7 @@ def create_response_object(
         "type": data_type or "about:blank",
     }
 
-    if response_type == "flask":
+    if response_format == "flask":
         # Importing Flask's Response class here lazily to avoid unnecessary
         # dependencies when not using Flask.
         from flask.wrappers import Response
@@ -138,7 +159,7 @@ def create_response_object(
 
         return resp, status_code
 
-    if response_type == "dict":
+    if response_format == "dict":
         if data is not None:
             obj["data"] = data
         return obj, status_code
@@ -158,6 +179,7 @@ def _split_cookies_from_object(
 
     Returns
     -------
+    tuple[Any | None, list[Cookie]]
         A tuple containing the data and a list of Cookie objects representing
         the cookies.
     """
@@ -175,3 +197,48 @@ def _split_cookies_from_object(
             data = data[0]
         return data, cookies
     return obj, []
+
+
+def _resolve_data_type(
+    accept_header: str | None,
+    supported_accept_headers: list[str] | None,
+    default: str = "application/json",
+) -> str:
+    """Resolve the data type for the response by matching against the supported
+    types.
+
+    Match wildcards like "*/*" or "application/*" with first match in supported
+    types. If the data type is not supported, resort to default type.
+
+    Parameters
+    ----------
+    accept_header
+        The Accept header from the request.
+    supported_accept_headers
+        A list of supported MIME types. If None, all types are supported.
+    default
+        The default MIME type to use if the provided accept_header is not
+        supported.
+
+    Returns
+    -------
+    str
+        The resolved MIME type to use for the response.
+    """
+    # If no data type provided or no supported types, return default
+    if not accept_header or not supported_accept_headers:
+        return default
+    # Return provided type if it matches supported type
+    if accept_header.lower() in supported_accept_headers:
+        return accept_header.lower()
+    # If MIME type wildcard is provided, return first supported type
+    if accept_header.startswith("*/"):
+        return supported_accept_headers[0]
+    # If MIME subtype is a wildcard, match prefix
+    if accept_header.endswith("/*"):
+        prefix = accept_header.split("/")[0].lower()
+        for supported in supported_accept_headers:
+            if supported.startswith(prefix):
+                return supported
+    # If not matched, return default
+    return default

{alpha_python-0.6.1 → alpha_python-0.6.3}/src/alpha_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpha-python
-Version: 0.6.1
+Version: 0.6.3
 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>
 License-Expression: MIT

{alpha_python-0.6.1 → alpha_python-0.6.3}/tests/test_encoder.py

@@ -3,11 +3,14 @@ from datetime import date, datetime, time, timezone
 from enum import Enum
 from typing import Any, Type, TypeVar
 from uuid import UUID
+from attrs import define
+from pydantic import BaseModel
+from dataclasses import dataclass
 
 import numpy as np
 import pandas as pd
 import pytest
-from alpha.encoder import JSONEncoder
+import alpha
 
 T = TypeVar("T")
 
@@ -15,7 +18,7 @@ T = TypeVar("T")
 @pytest.fixture
 def encoder_factory():
     def run_encoder(obj: Any, key: str):
-        json_ = json.dumps(obj, cls=JSONEncoder)
+        json_ = json.dumps(obj, cls=alpha.JSONEncoder)
         dict_ = json.loads(json_)
         return dict_[key]
 
@@ -75,6 +78,20 @@ class FakeModelToList:
         return [1, 2, 3]
 
 
+@dataclass
+class FakeDataclassModel:
+    dataclass: str
+
+
+@define
+class FakeAttrsModel:
+    attrs: str
+
+
+class FakePydanticModel(BaseModel):
+    pydantic: str
+
+
 @pytest.fixture
 def uuid_str():
     return "af6b2857-567c-490b-81e6-db21dbeba69b"
@@ -168,3 +185,27 @@ def test_open_api_model(encoder_factory, obj):
 def test_open_api_model_list(encoder_factory, obj):
     value = encoder_factory(obj, "open_api_model_list")
     assert value == [{"value": "abc"}]
+
+
+def test_dataclass_model_type(encoder_factory):
+    model = FakeDataclassModel
+    obj = json.dumps(model, cls=alpha.JSONEncoder)
+    assert obj == '"FakeDataclassModel"'
+
+
+def test_dataclass_model(encoder_factory):
+    model = FakeDataclassModel(dataclass="abc")
+    obj = encoder_factory(model, "dataclass")
+    assert obj == "abc"
+
+
+def test_attrs_model(encoder_factory):
+    model = FakeAttrsModel(attrs="abc")
+    obj = encoder_factory(model, "attrs")
+    assert obj == "abc"
+
+
+def test_pydantic_model(encoder_factory):
+    model = FakePydanticModel(pydantic="abc")
+    obj = encoder_factory(model, "pydantic")
+    assert obj == "abc"