apytizer 0.0.1a0__py3-none-any.whl → 0.0.1b1__py3-none-any.whl

apytizer/models/base_model.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/base/model.py
+"""Base model class.
+
+This module defines the implementation of a base model class.
+
+"""
+
+# Standard Library Imports
+from __future__ import annotations
+from typing import Any
+from typing import Generator
+from typing import Hashable
+from typing import Mapping
+from typing import Tuple
+
+# Local Imports
+from .abstract_model import AbstractModel
+from .. import states
+
+__all__ = ["BaseModel"]
+
+
+class BaseModel(AbstractModel):
+    """Implements a stateful model.
+
+    Args:
+        **kwargs: Data with which to set model state.
+
+    """
+
+    reference: Hashable
+
+    def __init__(self, **kwargs: Any):
+        self._state = states.LocalState(kwargs)
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._state
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            other.reference == self.reference
+            if isinstance(other, BaseModel)
+            else False
+        )
+
+    def __hash__(self) -> int:
+        return hash(self.reference)
+
+    def __getattr__(self, name: str) -> Any:
+        attr = self._state.get(name)
+        if not attr:
+            cls = self.__class__.__name__
+            message = f"type object '{cls!s}' has no attribute '{name!s}'"
+            raise AttributeError(message)
+
+        return attr
+
+    def __getitem__(self, key: str) -> Any:
+        value = self._state[key]
+        return value
+
+    def __iter__(self) -> Generator[Tuple[str, Any], None, None]:
+        yield from self._state.items()
+
+    def __repr__(self) -> str:
+        return self.__class__.__name__
+
+    def update(self, __m: Mapping[str, Any], **kwargs: Any) -> None:
+        """Update local state with provided data.
+
+        Args:
+            __m (optional): Mapping with which to update local state.
+            **kwargs: Data with which to update local state.
+
+        """
+        self._state.update(__m, **kwargs)
+
+    def rollback(self) -> None:
+        """Rollback changes to local state."""
+        self._state.rollback()
+
+    def save(self) -> None:
+        """Save changes to local state."""
+        self._state.save()

apytizer/protocols.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/protocols.py
+
+# Standard Library Imports
+import enum
+import re
+from typing import Optional
+
+__all__ = ["Protocol", "get_protocol"]
+
+
+@enum.unique
+class Protocol(str, enum.Enum):
+    """Implements standard application layer protocols."""
+
+    HTTP = "http"
+    HTTPS = "https"
+
+
+# ----------------------------------------------------------------------------
+# Selectors
+# ----------------------------------------------------------------------------
+def get_protocol(
+    url: str, default: Optional[Protocol] = None
+) -> Optional[Protocol]:
+    """Get protocol from URL.
+
+    Args:
+        url: URL from which to get protocol.
+        default (optional): Default protocol. Default ``None``.
+
+    Returns:
+        Protocol.
+
+    """
+    match = re.match(r"\w+(?=://)", url, re.I)
+    result = Protocol(match.group(0)) if match else default
+    return result

apytizer/repositories/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/repositories/__init__.py
+
+# Local Imports
+from .abstract_repository import *
+from .managed_repository import *

apytizer/repositories/abstract_repository.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/repositories/abstract_repository.py
+"""Abstract repository class interface.
+
+This module defines an abstract repository class which provides an interface
+for subclasses to implement.
+
+"""
+
+# Standard Library Imports
+import abc
+from typing import Any
+from typing import List
+from typing import TYPE_CHECKING
+
+# Local Imports
+if TYPE_CHECKING:
+    from ..models import AbstractModel
+
+__all__ = ["AbstractRepository"]
+
+
+class AbstractRepository(abc.ABC):
+    """Represents an abstract repository."""
+
+    @property
+    def objects(self) -> List[AbstractModel]:
+        """Objects in repository."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def add(self, obj: AbstractModel, /) -> None:
+        """Abstract method to add an object to repository.
+
+        This method only adds an object to the local state of the repository.
+        New objects are not sent to the associated endpoint until the client
+        commits changes to the repository.
+
+        Args:
+            obj: Instance of an abstract model subclass.
+
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get(self, ref: Any, *args: Any, **kwargs: Any) -> AbstractModel:
+        """Abstract method to get an object from the repository.
+
+        If the object is not found in local state, a request is send to the
+        associated endpoint.
+
+        Args:
+            ref: Reference to object.
+            *args: Positional arguments.
+            **kwargs: Keyword arguments.
+
+        Returns:
+            Instance of an abstract model subclass.
+
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def remove(self, obj: AbstractModel, /) -> None:
+        """Abstract method to remove an object from repository.
+
+        Args:
+            obj: Instance of an abstract model subclass.
+
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def commit(self) -> None:
+        """Abstract method for committing changes to objects."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def rollback(self) -> None:
+        """Abstract method for rolling back changes to objects."""
+        raise NotImplementedError

apytizer/repositories/managed_repository.py

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/repositories/managed_repository.py
+"""Managed Repository Class.
+
+This module defines a managed repository class.
+
+"""
+
+# Standard Library Imports
+from typing import Any
+from typing import List
+from typing import Optional
+from typing import Set
+from typing import TYPE_CHECKING
+
+# Local Imports
+from .abstract_repository import AbstractRepository
+
+if TYPE_CHECKING:
+    from ..managers import AbstractManager
+    from ..models import AbstractModel
+
+__all__ = ["ManagedRepository"]
+
+
+class ManagedRepository(AbstractRepository):
+    """Implements a managed repository.
+
+    Args:
+        manager: Manager.
+        objects (optional): Objects to include in repository.
+
+    """
+
+    def __init__(
+        self,
+        manager: AbstractManager,
+        objects: Optional[List[AbstractModel]] = None,
+    ) -> None:
+        self._manager = manager
+        self._objects: Set[AbstractModel] = set(objects or [])
+
+    @property
+    def objects(self) -> List[AbstractModel]:
+        """Objects in repository."""
+        result = list(self._objects)
+        return result
+
+    def add(self, obj: AbstractModel) -> None:
+        """Add an object to the repository.
+
+        Args:
+            obj: Object to add.
+
+        """
+        self._objects.add(obj)
+
+    def get(self, ref: Any) -> AbstractModel:
+        """Get an object from the repository.
+
+        Args:
+            ref: Reference to object.
+
+        Returns:
+            Object.
+
+        """
+        try:
+            result = next(obj for obj in self.objects if obj.reference == ref)
+        except StopIteration:
+            result = self._manager.read(ref)
+            self._objects.add(result)
+
+        return result
+
+    def remove(self, obj: AbstractModel) -> None:
+        """Remove an object from the repository.
+
+        Args:
+            obj: Object to remove.
+
+        """
+        self._manager.delete(obj)
+        self._objects.discard(obj)
+
+    def commit(self) -> None:
+        """Commit changes to objects in the repository."""
+        raise NotImplementedError
+
+    def rollback(self) -> None:
+        """Rollback changes to objects in the repository."""
+        raise NotImplementedError

apytizer/routes/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/routes/__init__.py
+
+# Local Imports
+from .abstract_route import *
+from .base_route import *

apytizer/routes/abstract_route.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/routes/abstract_route.py
+
+# Standard Library Imports
+from __future__ import annotations
+import abc
+
+__all__ = ["AbstractRoute"]
+
+
+class AbstractRoute(abc.ABC):
+    """Represents an abstract route."""
+
+    @abc.abstractmethod
+    def __add__(self, other: object) -> AbstractRoute:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __eq__(self, other: object) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __hash__(self) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __str__(self) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __truediv__(self, other: object) -> AbstractRoute:
+        raise NotImplementedError

apytizer/routes/base_route.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/routes/base_route.py
+
+# Standard Library Imports
+from typing import List
+
+# Local Imports
+from .abstract_route import AbstractRoute
+
+__all__ = ["Route"]
+
+
+class Route(AbstractRoute):
+    """Implements a route.
+
+    Args:
+        __value: Value.
+
+    """
+
+    def __init__(self, __value: str = "/", /) -> None:
+        if not isinstance(__value, (AbstractRoute, str)):  # type: ignore
+            message = f"expected type 'str', got {type(__value)} instead"
+            raise TypeError(message)
+
+        self._value = str(__value).strip("/") + "/"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, (AbstractRoute, str)):
+            return False
+
+        other_segments = get_segments(str(other))
+        self_segments = get_segments(self._value)
+        result = segments_are_equal(other_segments, self_segments)
+        return result
+
+    def __hash__(self) -> int:
+        return hash(self._value.lower())
+
+    def __len__(self) -> int:
+        return len(get_segments(self._value))
+
+    def __str__(self) -> str:
+        return self._value
+
+    def __gt__(self, other: object) -> bool:
+        if not isinstance(other, (AbstractRoute, str)):
+            return False
+
+        self_segments = get_segments(self._value)
+        other_segments = get_segments(str(other))
+        result = tuple(self_segments) > tuple(other_segments)
+        return result
+
+    def __lt__(self, other: object) -> bool:
+        if not isinstance(other, (AbstractRoute, str)):
+            return False
+
+        self_segments = get_segments(self._value)
+        other_segments = get_segments(str(other))
+        result = tuple(self_segments) < tuple(other_segments)
+        return result
+
+    def __add__(self, other: object) -> AbstractRoute:
+        if not isinstance(other, str):
+            message = f"expected type 'str', got {type(other)} instead"
+            raise TypeError(message)
+
+        result = Route(self._value + other.strip("/"))
+        return result
+
+    def __truediv__(self, other: object) -> AbstractRoute:
+        if not isinstance(other, str):
+            message = f"expected type 'str', got {type(other)} instead"
+            raise TypeError(message)
+
+        result = Route(self._value + other.strip("/"))
+        return result
+
+
+# ----------------------------------------------------------------------------
+# Helpers
+# ----------------------------------------------------------------------------
+def count_segments(__value: str, /) -> int:
+    """Get number of segments.
+
+    Args:
+        __value: Value for which to get number of segments.
+
+    Returns:
+        Number of segments.
+
+    """
+    result = len(get_segments(__value))
+    return result
+
+
+def get_segments(__value: str, /) -> List[str]:
+    """Get segments of string seperated by slashes.
+
+    Args:
+        __value: Value for which to get segments.
+
+    Returns:
+        Segments.
+
+    """
+    if not isinstance(__value, str):  # type: ignore
+        message = f"expected type 'str', got {type(__value)} instead"
+        raise TypeError(message)
+
+    result = __value.strip("/").split("/")
+    return result
+
+
+def segments_are_equal(
+    first: List[str], second: List[str], placeholder: str = r"{}"
+) -> bool:
+    """Check whether segments are equal.
+
+    Args:
+        first: First list of segments.
+        second: Second list of segments.
+        placeholder: Placeholder. Default ``{}``.
+
+    Returns:
+        Whether segments are equal.
+
+    """
+    if len(first) != len(second):
+        return False
+
+    result = all(
+        left.lower() == right.lower()
+        for left, right in zip(first, second)
+        if right != placeholder
+    )
+    return result

apytizer/sessions/__init__.py

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/sessions/__init__.py
+
+# Standard Library Imports
+from typing import Type
+from typing import TYPE_CHECKING
+
+# Local Imports
+from .abstract_session import *
+from .requests_session import *
+
+if TYPE_CHECKING:
+    from ..engines import AbstractEngine
+
+
+class sessionmaker:
+    """Implements a sessionmaker."""
+
+    def __init__(
+        self, class_: Type[RequestsSession] = RequestsSession
+    ) -> None:
+        self._session_type = class_
+
+    def __call__(self, __engine: "AbstractEngine", /) -> RequestsSession:
+        result = self._session_type(
+            adapters=getattr(__engine, "adapters", None),
+            auth=getattr(__engine, "auth", None),
+            cert=getattr(__engine, "cert", None),
+            proxies=getattr(__engine, "proxies", None),
+            stream=getattr(__engine, "stream", False),
+            verify=getattr(__engine, "verify", True),
+        )
+        return result

apytizer/sessions/abstract_session.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/sessions/abstract_session.py
+"""Abstract Session Class.
+
+This module defines an abstract session class which provides an interface
+for subclasses to implement.
+
+"""
+
+# Standard Library Imports
+import abc
+from typing import Any
+from typing import TYPE_CHECKING
+
+# Third-Party Imports
+import requests
+from requests.adapters import HTTPAdapter
+
+if TYPE_CHECKING:
+    from ..protocols import Protocol
+
+__all__ = ["AbstractSession"]
+
+
+class AbstractSession(abc.ABC):
+    """Represents an abstract session."""
+
+    @abc.abstractmethod
+    def start(self) -> None:
+        """Starts session."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def close(self) -> None:
+        """Destroys session."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def mount(self, protocol: "Protocol", adapter: HTTPAdapter) -> None:
+        """Registers a connection adapter to a protocol prefix.
+
+        Args:
+            protocol: Protocol prefix on which to mount adapter.
+            adapter: HTTP adapter to apply to connection.
+
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def send(
+        self, __request: requests.Request, /, **kwargs: Any
+    ) -> requests.Response:
+        """Send an HTTP request.
+
+        Args:
+            __request: Request to send.
+            **kwargs: Keyword arguments.
+
+        Returns:
+            Response.
+
+        """
+        raise NotImplementedError

apytizer/sessions/requests_session.py

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/sessions/requests_session.py
+"""Requests Session Class.
+
+This module defines the requests session class implementation.
+
+"""
+
+# Standard Library Imports
+import logging
+from typing import Any
+from typing import Dict
+from typing import MutableMapping
+from typing import Optional
+from typing import Tuple
+from typing import Union
+from typing import final
+
+# Third-Party Imports
+import requests
+from requests.auth import AuthBase
+from requests.adapters import HTTPAdapter
+
+# Local Imports
+from .abstract_session import AbstractSession
+from ..protocols import Protocol
+
+__all__ = ["RequestsSession"]
+
+
+log = logging.getLogger("apytizer")
+
+
+class RequestsSession(AbstractSession):
+    """Implements a requests session.
+
+    The `RequestsSession` class provides `start` and `close` methods for manual
+    control of the session.
+
+    A session instance can also be used as a context manager.
+
+    Args:
+        adapters (optional): Connection adapters. Default ``None``.
+        auth (optional): Authentication header. default ``None``.
+        cert (optional): Client certificate. Default ``None``.
+        proxies (optional): Protocols mapped to proxy URLs. Default ``None``.
+        stream (optional): Whether to stream response content. Default ``False``.
+        verify (optional): Whether to verify certificate. Default ``True``.
+
+    .. Requests Documentation:
+        https://docs.python-requests.org/en/latest/api/#request-sessions
+
+    """
+
+    def __init__(
+        self,
+        *,
+        adapters: Optional[Dict[Protocol, HTTPAdapter]] = None,
+        auth: Optional[Union[AuthBase, Tuple[str, str]]] = None,
+        cert: Optional[Union[str, Tuple[str, str]]] = None,
+        proxies: Optional[MutableMapping[str, str]] = None,
+        stream: Optional[bool] = False,
+        verify: Optional[bool] = True,
+    ) -> None:
+        self._session = requests.Session()
+        self._session.auth = auth
+        self._session.cert = cert
+        self._session.proxies = proxies  # type: ignore
+        self._session.stream = stream  # type: ignore
+        self._session.verify = verify  # type: ignore
+
+        if adapters is not None:
+            for protocol, adapter in adapters.items():
+                self._session.mount(protocol, adapter)
+
+    @final
+    def __enter__(self) -> AbstractSession:
+        """Starts session as context manager."""
+        self.start()
+        return self
+
+    @final
+    def __exit__(self, *_) -> None:
+        """Stops session as context manager."""
+        self.close()
+
+    def start(self) -> None:
+        """Starts session."""
+        log.debug("Starting session...")
+
+    def close(self, *_: Any) -> None:
+        """Destroys session."""
+        self._session.close()
+        log.debug("Session closed")
+
+    def mount(self, protocol: Protocol, adapter: HTTPAdapter) -> None:
+        """Registers connection adapter to protocol prefix.
+
+        Args:
+            protocol: Protocol on which to mount adapter.
+            adapter: HTTP adapter to apply to connection.
+
+        """
+        self._session.mount(f"{protocol.value!s}://", adapter)
+        log.debug(
+            "Mounted %(adapter)s adapter to %(protocol)s protocol",
+            {"adapter": adapter, "protocol": protocol.value},
+        )
+
+    def send(
+        self, __request: requests.Request, /, **kwargs: Any
+    ) -> requests.Response:
+        """Send an HTTP request.
+
+        Args:
+            __request: Request to send.
+            **kwargs (optional): Keyword arguments.
+
+        Returns:
+            Response object.
+
+        """
+        request = self._session.prepare_request(__request)
+        response = self._session.send(request, **kwargs)
+        return response