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

apytizer/media_types.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/media_types.py
+"""Media types (previously MIME types) and subtypes.
+
+.. _IANA:
+    https://www.iana.org/assignments/media-types/media-types.xhtml
+
+"""
+
+# Standard Library Imports
+from __future__ import annotations
+import enum
+import mimetypes
+import re
+from typing import Optional
+
+
+@enum.unique
+class MediaType(str, enum.Enum):
+    """Implements media types."""
+
+    @property
+    def type(self) -> Optional[str]:
+        """Content type."""
+        match = re.match(r"[a-z]+(?=/)", self._value_)
+        result = match.group(0) if match else None
+        return result
+
+    @property
+    def subtype(self) -> Optional[str]:
+        """Content subtype."""
+        match = re.search(r"(?<=/)[a-z+-]+", self._value_)
+        result = match.group(0) if match else None
+        return result
+
+    @property
+    def extension(self) -> Optional[str]:
+        """File extension."""
+        result = mimetypes.guess_extension(self._value_)
+        return result
+
+    # application
+    APPLICATION_JAVASCRIPT = "application/javascript"
+    APPLICATION_JSON = "application/json"
+    APPLICATION_MANIFEST = "application/manifest+json"
+    APPLICATION_MSWORD = "application/msword"
+    APPLICATION_OCTET_STREAM = "application/octet-stream"
+    APPLICATION_ODA = "application/oda"
+    APPLICATION_PDF = "application/pdf"
+    APPLICATION_PKCS7_MIME = "application/pkcs7-mime"
+    APPLICATION_POSTSCRIPT = "application/postscript"
+    APPLICATION_RTF = "application/rtf"
+    APPLICATION_RTX = "application/rtx"
+    APPLICATION_SQL = "application/sql"
+    APPLICATION_TAR = "application/x-tar"
+    APPLICATION_XML = "application/xml"
+    APPLICATION_ZIP = "application/zip"
+
+    # audio
+    AUDIO_AIFF = "audio/x-aiff"
+    AUDIO_BASIC = "audio/basic"
+    AUDIO_MP4 = "audio/mp4"
+    AUDIO_MPEG = "audio/mpeg"
+    AUDIO_MIDI = "audio/midi"
+    AUDIO_REALAUDIO = "audio/x-pn-realaudio"
+    AUDIO_WAV = "audio/x-wav"
+
+    # image
+    IMAGE_BMP = "image/bmp"
+    IMAGE_GIF = "image/gif"
+    IMAGE_ICON = "image/vnd.microsoft.icon"
+    IMAGE_IEF = "image/ief"
+    IMAGE_JPEG = "image/jpeg"
+    IMAGE_PICT = "image/pict"
+    IMAGE_PNG = "image/png"
+    IMAGE_RGB = "image/x-rgb"
+    IMAGE_SVG = "image/svg+xml"
+    IMAGE_TIFF = "image/tiff"
+
+    # message
+    MESSAGE_PARTIAL = "message/partial"
+    MESSAGE_RFC822 = "message/rfc822"
+
+    # multipart
+    MULTIPART_BYTERANGES = "multipart/byteranges"
+    MULTIPART_ENCRYPTED = "multipart/encrypted"
+    MULTIPART_FORM_DATA = "multipart/form-data"
+    MULTIPART_HEADER_SET = "multipart/header-set"
+    MULTIPART_MULTILINGUAL = "multipart/multilingual"
+    MULTIPART_SIGNED = "multipart/signed"
+
+    # text
+    TEXT_CSS = "text/css"
+    TEXT_CSV = "text/csv"
+    TEXT_DNS = "text/dns"
+    TEXT_HTML = "text/html"
+    TEXT_JAVASCRIPT = "text/javascript"
+    TEXT_MARKDOWN = "text/markdown"
+    TEXT_PLAIN = "text/plain"
+    TEXT_PYTHON = "text/x-python"
+    TEXT_RTF = "text/rtf"
+    TEXT_RTX = "text/rtx"
+    TEXT_SETEXT = "text/x-setext"
+    TEXT_SGML = "text/x-sgml"
+    TEXT_STRINGS = "text/strings"
+    TEXT_TSV = "text/tab-separated-values"
+    TEXT_VCARD = "text/x-vcard"
+    TEXT_XML = "text/xml"
+
+    # video
+    VIDEO_H264 = "video/H264"
+    VIDEO_MP4 = "video/mp4"
+    VIDEO_MPEG = "video/mpeg"
+    VIDEO_MSVIDEO = "video/x-msvideo"
+    VIDEO_QUICKTIME = "video/quicktime"
+    VIDEO_RAW = "video/raw"
+    VIDEO_SGI_MOVIE = "video/x-sgi-movie"
+    VIDEO_WEBM = "video/webm"

apytizer/models/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/models/__init__.py
+
+# Local Imports
+from .abstract_model import *
+from .base_model import *

apytizer/models/abstract_model.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+# src/apytizer/models/abstract_model.py
+"""Abstract model class interface.
+
+This module defines an abstract model class which provides an interface
+for subclasses to implement.
+
+"""
+
+# Standard Library Imports
+from __future__ import annotations
+import abc
+from typing import Any
+from typing import Mapping
+from typing import TYPE_CHECKING
+
+# Local Imports
+if TYPE_CHECKING:
+    from ..managers import AbstractManager
+    from ..states import AbstractState
+
+__all__ = ["AbstractModel"]
+
+
+class AbstractModel(abc.ABC):
+    """Represents an abstract model."""
+
+    @property
+    def manager(self) -> AbstractManager:
+        """Manager for model."""
+        return getattr(self, "__manager__")
+
+    @manager.setter
+    def manager(self, manager: AbstractManager, /) -> None:
+        setattr(self, "__manager__", manager)
+
+    @manager.deleter
+    def manager(self) -> None:
+        delattr(self, "__manager__")
+
+    @abc.abstractmethod
+    def __eq__(self, other: object) -> bool:
+        """Abstract method for determining whether model is equal to another.
+
+        Returns:
+            Whether models are equal.
+
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __hash__(self) -> int:
+        """Abstract method for returning the hash value of a model.
+
+        Returns:
+            Hash value.
+
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __repr__(self) -> str:
+        """Abstract method for returning string representation of model."""
+        raise NotImplementedError
+
+
+class AbstractStatefulModel(AbstractModel):
+    """Class represents an abstract stateful model."""
+
+    @property
+    @abc.abstractmethod
+    def state(self) -> AbstractState:
+        """State."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __contains__(self, other: object) -> bool:
+        """Abstract method for determining whether object in state.
+
+        Returns:
+            Whether object in state.
+
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __getattr__(self, name: str) -> Any:
+        """Abstract method for getting an attribute from state.
+
+        Returns:
+            Value of attribute.
+
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __getitem__(self, name: str) -> Any:
+        """Abstract method for getting an item from state.
+
+        Returns:
+            Value of item.
+
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def update(self, __m: Mapping[str, Any], **kwargs: Any) -> None:
+        """Abstract method for updating state of model."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def rollback(self) -> None:
+        """Abstract method for rolling back changes to state of model."""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def save(self) -> None:
+        """Abstract method for saving changes to state of model."""
+        raise NotImplementedError

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