appier 1.34.12__tar.gz → 1.35.1__tar.gz

{appier-1.34.12/src/appier.egg-info → appier-1.35.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: appier
-Version: 1.34.12
+Version: 1.35.1
 Summary: Appier Framework
 Home-page: http://appier.hive.pt
 Author: Hive Solutions Lda.

{appier-1.34.12 → appier-1.35.1}/setup.py

@@ -44,7 +44,7 @@ def read_file(path):
 
 setuptools.setup(
     name="appier",
-    version="1.34.12",
+    version="1.35.1",
     author="Hive Solutions Lda.",
     author_email="development@hive.pt",
     description="Appier Framework",

{appier-1.34.12 → appier-1.35.1}/src/appier/__init__.py

@@ -144,7 +144,16 @@ from .bus import Bus, MemoryBus, RedisBus
 from .cache import Cache, MemoryCache, FileCache, RedisCache, SerializedCache
 from .component import Component
 from .compress import Compress
-from .config import conf, conf_prefix, conf_suffix, conf_s, conf_r, conf_d, conf_ctx
+from .config import (
+    conf,
+    conf_prefix,
+    conf_suffix,
+    conf_s,
+    conf_r,
+    conf_d,
+    conf_ctx,
+    conf_override,
+)
 from .controller import Controller
 from .crypt import Cipher, RC4, Spritz
 from .data import (

appier-1.35.1/src/appier/amqp.pyi

@@ -0,0 +1,14 @@
+from typing import Any
+
+URL: str
+TIMEOUT: int
+connection: Any | None
+
+class AMQP:
+    url: str | None
+    _connection: Any | None
+    def __init__(self, url: str | None = ...): ...
+    def get_connection(self, url: str | None = ..., timeout: int = ...) -> Any: ...
+
+def get_connection(url: str = ..., timeout: int = ...) -> Any: ...
+def properties(*args, **kwargs) -> Any: ...

appier-1.35.1/src/appier/api.pyi

@@ -0,0 +1,168 @@
+from typing import Any, Callable, Self
+
+from .base import App
+from .observer import Observable
+
+class API(Observable):
+    SINGLETON: Self | None
+    owner: App
+    auth_callback: Callable | None
+    def __init__(self, owner: App = ..., *args, **kwargs): ...
+    @classmethod
+    def singleton(cls, *args, **kwargs) -> Self: ...
+    def get(
+        self,
+        url: str,
+        headers: dict[str, Any] | None = ...,
+        params: dict[str, Any] | None = ...,
+        handle: bool | None = ...,
+        silent: bool | None = ...,
+        redirect: bool | None = ...,
+        timeout: int | float | None = ...,
+        callback: bool = ...,
+        extra: dict[str, Any] | None = ...,
+        **kwargs
+    ) -> Any: ...
+    def post(
+        self,
+        url: str,
+        data: Any = ...,
+        data_j: Any = ...,
+        data_m: Any = ...,
+        headers: dict[str, Any] | None = ...,
+        params: dict[str, Any] | None = ...,
+        mime: str | None = ...,
+        handle: bool | None = ...,
+        silent: bool | None = ...,
+        redirect: bool | None = ...,
+        timeout: int | float | None = ...,
+        callback: bool = ...,
+        extra: dict[str, Any] | None = ...,
+        **kwargs
+    ) -> Any: ...
+    def put(
+        self,
+        url: str,
+        data: Any = ...,
+        data_j: Any = ...,
+        data_m: Any = ...,
+        headers: dict[str, Any] | None = ...,
+        params: dict[str, Any] | None = ...,
+        mime: str | None = ...,
+        handle: bool | None = ...,
+        silent: bool | None = ...,
+        redirect: bool | None = ...,
+        timeout: int | float | None = ...,
+        callback: bool = ...,
+        extra: dict[str, Any] | None = ...,
+        **kwargs
+    ) -> Any: ...
+    def delete(
+        self,
+        url: str,
+        headers: dict[str, Any] | None = ...,
+        params: dict[str, Any] | None = ...,
+        handle: bool | None = ...,
+        silent: bool | None = ...,
+        redirect: bool | None = ...,
+        timeout: int | float | None = ...,
+        callback: bool = ...,
+        extra: dict[str, Any] | None = ...,
+        **kwargs
+    ) -> Any: ...
+    def patch(
+        self,
+        url: str,
+        data: Any = ...,
+        data_j: Any = ...,
+        data_m: Any = ...,
+        headers: dict[str, Any] | None = ...,
+        params: dict[str, Any] | None = ...,
+        mime: str | None = ...,
+        handle: bool | None = ...,
+        silent: bool | None = ...,
+        redirect: bool | None = ...,
+        timeout: int | float | None = ...,
+        callback: bool = ...,
+        extra: dict[str, Any] | None = ...,
+        **kwargs
+    ) -> Any: ...
+    def request(self, method: Callable, *args, **kwargs) -> Any: ...
+    def build(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
+        method: str,
+        url: str,
+        data: Any = ...,
+        data_j: Any = ...,
+        data_m: Any = ...,
+        headers: dict[str, Any] | None = ...,
+        params: dict[str, Any] | None = ...,
+        mime: str | None = ...,
+        kwargs: dict[str, Any] | None = ...,
+    ) -> None: ...
+    def handle_error(self, error: Exception) -> None: ...
+    @property
+    def logger(self) -> Any: ...
+
+class OAuthAPI(API):
+    DIRECT_MODE: int
+    OAUTH_MODE: int
+    UNSET_MODE: int
+    mode: int
+    def __init__(self, *args, **kwargs): ...
+    def handle_error(self, error: Exception) -> None: ...
+    def is_direct(self) -> bool: ...
+    def is_oauth(self) -> bool: ...
+    def _get_mode(self) -> int: ...
+
+class OAuth1API(OAuthAPI):
+    oauth_token: str | None
+    oauth_token_secret: str | None
+    client_key: str | None
+    client_secret: str | None
+    def __init__(self, *args, **kwargs): ...
+    def build(
+        self,
+        method: str,
+        url: str,
+        data: Any = ...,
+        data_j: Any = ...,
+        data_m: Any = ...,
+        headers: dict[str, Any] | None = ...,
+        params: dict[str, Any] | None = ...,
+        mime: str | None = ...,
+        kwargs: dict[str, Any] | None = ...,
+    ) -> None: ...
+    def auth_header(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, Any],
+        kwargs: dict[str, Any],
+        sign_method: str = ...,
+    ) -> None: ...
+    @property
+    def auth_default(self) -> bool: ...
+
+class OAuth2API(OAuthAPI):
+    access_token: str | None
+    def __init__(self, *args, **kwargs): ...
+    def build(
+        self,
+        method: str,
+        url: str,
+        data: Any = ...,
+        data_j: Any = ...,
+        data_m: Any = ...,
+        headers: dict[str, Any] | None = ...,
+        params: dict[str, Any] | None = ...,
+        mime: str | None = ...,
+        kwargs: dict[str, Any] | None = ...,
+    ) -> None: ...
+    def get_access_token(self) -> str: ...
+    @property
+    def oauth_types(self) -> tuple[str, ...]: ...
+    @property
+    def oauth_param(self) -> str: ...
+    @property
+    def token_default(self) -> bool: ...

{appier-1.34.12 → appier-1.35.1}/src/appier/asgi.py

@@ -189,9 +189,16 @@ class ASGIApp(object):
             self._ensure_start(ctx, start_response)
             await ctx["start_task"]
 
+            # ensures the result is a sequence for iteration and if it's
+            # not initializes it as an empty list, notice the special case
+            # of a string that should be converted into a single element list
+            result = result if result else []
+            if legacy.is_string(result):
+                result = [result]
+
             # iterates over the complete set of chunks in the response
             # iterator to send each of them to the client side
-            for chunk in result if result else []:
+            for chunk in result:
                 if asyncio.iscoroutine(chunk):
                     await chunk
                 elif asyncio.isfuture(chunk):

appier-1.35.1/src/appier/asgi.pyi

@@ -0,0 +1,74 @@
+from typing import Any, Callable, Coroutine
+
+class ASGIApp:
+    _asgi: ASGIApp | None
+    server_version: str | None
+    _server: Any | None
+    @classmethod
+    async def asgi_entry(
+        cls,
+        scope: dict[str, Any],
+        receive: Callable[[], Coroutine[Any, Any, dict[str, Any]]],
+        send: Callable[[dict[str, Any]], Coroutine[Any, Any, None]],
+    ) -> None: ...
+    def serve_uvicorn(self, host: str, port: int, **kwargs) -> None: ...
+    def serve_hypercorn(
+        self,
+        host: str,
+        port: int,
+        ssl: bool = ...,
+        key_file: str | None = ...,
+        cer_file: str | None = ...,
+        **kwargs
+    ) -> None: ...
+    def serve_daphne(self, host: str, port: int, **kwargs) -> None: ...
+    async def send(self, data: Any, content_type: str | None = ...) -> Any: ...
+    async def app_asgi(self, *args, **kwargs) -> Any: ...
+    async def application_asgi(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[[], Coroutine[Any, Any, dict[str, Any]]],
+        send: Callable[[dict[str, Any]], Coroutine[Any, Any, None]],
+    ) -> None: ...
+    async def asgi_lifespan(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[[], Coroutine[Any, Any, dict[str, Any]]],
+        send: Callable[[dict[str, Any]], Coroutine[Any, Any, None]],
+    ) -> None: ...
+    async def asgi_http(
+        self,
+        scope: dict[str, Any],
+        receive: Callable[[], Coroutine[Any, Any, dict[str, Any]]],
+        send: Callable[[dict[str, Any]], Coroutine[Any, Any, None]],
+    ) -> None: ...
+    async def _build_start_response(
+        self,
+        ctx: dict[str, Any],
+        send: Callable[[dict[str, Any]], Coroutine[Any, Any, None]],
+    ) -> Callable[[str, list[tuple[str, str]]], None]: ...
+    async def _build_sender(
+        self,
+        ctx: dict[str, Any],
+        send: Callable[[dict[str, Any]], Coroutine[Any, Any, None]],
+        start_response: Callable[[str, list[tuple[str, str]]], None],
+    ) -> Callable[[Any], Coroutine[Any, Any, None]]: ...
+    async def _build_body(
+        self,
+        receive: Callable[[], Coroutine[Any, Any, dict[str, Any]]],
+        max_size: int = ...,
+    ) -> Any: ...
+    async def _build_environ(
+        self,
+        scope: dict[str, Any],
+        body: Any,
+        sender: Callable[[Any], Coroutine[Any, Any, None]],
+    ) -> dict[str, Any]: ...
+    def _ensure_start(
+        self,
+        ctx: dict[str, Any],
+        start_response: Callable[[str, list[tuple[str, str]]], None],
+    ) -> None: ...
+
+def build_asgi(app_cls: type[ASGIApp]) -> Callable: ...
+def build_asgi_i(app: ASGIApp) -> Callable: ...

appier-1.35.1/src/appier/bus.pyi

@@ -0,0 +1,54 @@
+from threading import Thread
+from typing import Any, Callable, Self, Sequence
+
+from .base import App
+from .component import Component
+
+class Bus(Component):
+    def __init__(self, name: str = ..., owner: App = ..., *args, **kwargs): ...
+    @classmethod
+    def new(cls, *args, **kwargs) -> Self: ...
+    def bind(self, name: str, method: Callable) -> None: ...
+    def unbind(self, name: str, method: Callable | None = ...) -> None: ...
+    def trigger(self, name: str, *args, **kwargs) -> None: ...
+
+class MemoryBus(Bus):
+    _events: dict[str, list[Callable]]
+    def __init__(self, name: str = ..., owner: App = ..., *args, **kwargs): ...
+    def bind(self, name: str, method: Callable) -> None: ...
+    def unbind(self, name: str, method: Callable | None = ...) -> None: ...
+    def trigger(self, name: str, *args, **kwargs) -> None: ...
+    def _load(self, *args, **kwargs) -> None: ...
+    def _unload(self, *args, **kwargs) -> None: ...
+    def _get_state(self) -> dict[str, Sequence[Callable]]: ...
+    def _set_state(self, state: dict[str, Sequence[Callable]]) -> None: ...
+
+class RedisBus(Bus):
+    SERIALIZER: Any
+    GLOBAL_CHANNEL: str
+    _delay: bool
+    _events: dict[str, list[Callable]]
+    _name: str
+    _serializer: Any
+    _global_channel: str
+    _redis: Any
+    _pubsub: Any
+    _listener: RedisListener
+    def __init__(self, name: str = ..., owner: App = ..., *args, **kwargs): ...
+    def bind(self, name: str, method: Callable) -> None: ...
+    def unbind(self, name: str, method: Callable | None = ...) -> None: ...
+    def trigger(self, name: str, *args, **kwargs) -> None: ...
+    def _load(self, *args, **kwargs) -> None: ...
+    def _unload(self, *args, **kwargs) -> None: ...
+    def _get_state(self) -> dict[str, Sequence[Callable]]: ...
+    def _set_state(self, state: dict[str, Sequence[Callable]]) -> None: ...
+    def _open(self) -> None: ...
+    def _close(self) -> None: ...
+    def _loop(self, safe: bool = ...) -> None: ...
+    def _tick(self, item: dict[str, Any], safe: bool = ...) -> None: ...
+    def _to_channel(self, name: str) -> str: ...
+
+class RedisListener(Thread):
+    _bus: RedisBus
+    def __init__(self, bus: RedisBus): ...
+    def run(self) -> None: ...

{appier-1.34.12 → appier-1.35.1}/src/appier/config.py

@@ -39,6 +39,7 @@ __license__ = "Apache License, Version 2.0"
 import os
 import sys
 import json
+import contextlib
 
 from . import legacy
 
@@ -167,6 +168,31 @@ def conf_ctx():
     return dict(configs=dict(), config_f=dict())
 
 
+@contextlib.contextmanager
+def conf_override(name, value):
+    """
+    Context manager to temporarily override a configuration value.
+
+    Saves the original value, sets the new value, and restores the original
+    value (or removes it if it was None) when the context exits.
+
+    :type name: String
+    :param name: The name of the configuration key to override.
+    :type value: String
+    :param value: The temporary value to set for the configuration key.
+    """
+
+    original = conf(name, None)
+    conf_s(name, value)
+    try:
+        yield
+    finally:
+        if original == None:
+            conf_r(name)
+        else:
+            conf_s(name, original)
+
+
 def load(names=(FILE_NAME,), path=None, encoding="utf-8", ctx=None):
     paths = []
     homes = get_homes()

{appier-1.34.12 → appier-1.35.1}/src/appier/geo.py

@@ -38,6 +38,15 @@ from . import legacy
 
 
 class GeoResolver(object):
+    """
+    Resolves geo-location information for IP addresses using
+    a MaxMind city database that is loaded from disk.
+
+    The resolver tries known file locations, downloads the
+    compressed database when missing and exposes a simplified
+    structure for easier consumption.
+    """
+
     DB_NAME = "GeoLite2-City.mmdb"
     """ The name of the file that contains the GeoIP
     information database (to be used in execution) """

{appier-1.34.12 → appier-1.35.1}/src/appier/graph.py

@@ -105,7 +105,7 @@ class Graph(object):
         queue.push(src, priority=0)
 
         while queue.length() > 0:
-            (_, _, top) = queue.pop(full=True)
+            _, _, top = queue.pop(full=True)
             dist[top] = dist[top] if top in dist else defines.INFINITY
 
             edges = self.edges[top] if top in self.edges else []

{appier-1.34.12 → appier-1.35.1}/src/appier/model.pyi

@@ -42,6 +42,18 @@ class Model:
         before_callbacks: Sequence[Callable[[Self], None]] = ...,
         after_callbacks: Sequence[Callable[[Self], None]] = ...,
     ) -> Self: ...
+    def pre_validate(self) -> None: ...
+    def pre_save(self) -> None: ...
+    def pre_create(self) -> None: ...
+    def pre_update(self) -> None: ...
+    def pre_delete(self) -> None: ...
+    def post_validate(self) -> None: ...
+    def post_save(self) -> None: ...
+    def post_create(self) -> None: ...
+    def post_update(self) -> None: ...
+    def post_delete(self) -> None: ...
+    def pre_apply(self) -> None: ...
+    def post_apply(self) -> None: ...
     @property
     def identity(self) -> Any: ...
     ...

{appier-1.34.12 → appier-1.35.1}/src/appier/storage.py

@@ -53,19 +53,19 @@ class StorageEngine(object):
         raise exceptions.NotImplementedError()
 
     @classmethod
-    def seek(self, file, *args, **kwargs):
+    def seek(cls, file, *args, **kwargs):
         raise exceptions.NotImplementedError()
 
     @classmethod
-    def cleanup(self, file, *args, **kwargs):
+    def cleanup(cls, file, *args, **kwargs):
         raise exceptions.NotImplementedError()
 
     @classmethod
-    def is_seekable(self):
+    def is_seekable(cls):
         return False
 
     @classmethod
-    def is_stored(self):
+    def is_stored(cls):
         return False
 
     @classmethod
@@ -75,7 +75,9 @@ class StorageEngine(object):
 
 class BaseEngine(StorageEngine):
     @classmethod
-    def load(cls, file, *args, **kwargs):
+    def load(  # pyright: ignore[reportIncompatibleMethodOverride]
+        cls, file, *args, **kwargs
+    ):
         force = kwargs.get("force", False)
         if not file.file_name:
             return
@@ -92,18 +94,24 @@ class BaseEngine(StorageEngine):
         finally:
             handle.close()
 
-        cls._compute()
+        cls._compute(file)
 
     @classmethod
-    def store(cls, file, *args, **kwargs):
+    def store(  # pyright: ignore[reportIncompatibleMethodOverride]
+        cls, file, *args, **kwargs
+    ):
         pass
 
     @classmethod
-    def delete(cls, file, *args, **kwargs):
+    def delete(  # pyright: ignore[reportIncompatibleMethodOverride]
+        cls, file, *args, **kwargs
+    ):
         pass
 
     @classmethod
-    def read(cls, file, *args, **kwargs):
+    def read(  # pyright: ignore[reportIncompatibleMethodOverride]
+        cls, file, *args, **kwargs
+    ):
         # tries to determine the requested size for# the file
         # reading in case none is defined the handled flag
         # handling is ignored and the data returned immediately
@@ -125,19 +133,23 @@ class BaseEngine(StorageEngine):
         return None
 
     @classmethod
-    def cleanup(cls, file, *args, **kwargs):
+    def cleanup(  # pyright: ignore[reportIncompatibleMethodOverride]
+        cls, file, *args, **kwargs
+    ):
         if not hasattr(file, "handled"):
             return
         del file._handled
 
     @classmethod
-    def is_stored(self):
+    def is_stored(cls):  # pyright: ignore[reportIncompatibleMethodOverride]
         return True
 
 
 class FsEngine(StorageEngine):
     @classmethod
-    def store(cls, file, *args, **kwargs):
+    def store(  # pyright: ignore[reportIncompatibleMethodOverride]
+        cls, file, *args, **kwargs
+    ):
         file_path = cls._file_path(file)
         file_data = file.data or b""
         handle = open(file_path, "wb")
@@ -147,16 +159,22 @@ class FsEngine(StorageEngine):
             handle.close()
 
     @classmethod
-    def load(cls, file, *args, **kwargs):
+    def load(  # pyright: ignore[reportIncompatibleMethodOverride]
+        cls, file, *args, **kwargs
+    ):
         cls._compute(file)
 
     @classmethod
-    def delete(cls, file, *args, **kwargs):
+    def delete(  # pyright: ignore[reportIncompatibleMethodOverride]
+        cls, file, *args, **kwargs
+    ):
         file_path = cls._file_path(file, ensure=False)
         os.remove(file_path)
 
     @classmethod
-    def read(cls, file, *args, **kwargs):
+    def read(  # pyright: ignore[reportIncompatibleMethodOverride]
+        cls, file, *args, **kwargs
+    ):
         data = None
         size = kwargs.get("size", None)
         handle = cls._handle(file)
@@ -164,11 +182,14 @@ class FsEngine(StorageEngine):
             data = handle.read(size or -1)
         finally:
             is_final = True if not size or not data else False
-            is_final and cls.cleanup(file)
+            if is_final:
+                cls.cleanup(file)
         return data
 
     @classmethod
-    def seek(cls, file, *args, **kwargs):
+    def seek(  # pyright: ignore[reportIncompatibleMethodOverride]
+        cls, file, *args, **kwargs
+    ):
         offset = kwargs.get("offset", None)
         if offset == None:
             return
@@ -176,14 +197,16 @@ class FsEngine(StorageEngine):
         handle.seek(offset)
 
     @classmethod
-    def cleanup(cls, file, *args, **kwargs):
+    def cleanup(  # pyright: ignore[reportIncompatibleMethodOverride]
+        cls, file, *args, **kwargs
+    ):
         if not hasattr(file, "_handle"):
             return
         file._handle.close()
         del file._handle
 
     @classmethod
-    def is_seekable(self):
+    def is_seekable(cls):  # pyright: ignore[reportIncompatibleMethodOverride]
         return True
 
     @classmethod
@@ -207,7 +230,7 @@ class FsEngine(StorageEngine):
     @classmethod
     def _file_path(cls, file, ensure=True, base=None):
         # verifies that the standard params value is defined and
-        # if that's no the case defaults the value, then tries to
+        # if that's not the case defaults the value, then tries to
         # retrieve a series of parameters for file path discovery
         params = file.params or {}
         file_path = params.get("file_path", None)

appier-1.35.1/src/appier/storage.pyi

@@ -0,0 +1,61 @@
+from typing import Any
+
+from .typesf import File
+
+class StorageEngine:
+    @classmethod
+    def load(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def store(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def delete(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def read(cls, file: File, *args, **kwargs) -> bytes | None: ...
+    @classmethod
+    def seek(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def cleanup(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def is_seekable(cls) -> bool: ...
+    @classmethod
+    def is_stored(cls) -> bool: ...
+    @classmethod
+    def _compute(cls, file: File, *args, **kwargs) -> None: ...
+
+class BaseEngine(StorageEngine):
+    @classmethod
+    def load(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def store(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def delete(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def read(cls, file: File, *args, **kwargs) -> bytes | None: ...
+    @classmethod
+    def cleanup(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def is_stored(cls) -> bool: ...
+
+class FsEngine(StorageEngine):
+    @classmethod
+    def store(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def load(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def delete(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def read(cls, file: File, *args, **kwargs) -> bytes | None: ...
+    @classmethod
+    def seek(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def cleanup(cls, file: File, *args, **kwargs) -> None: ...
+    @classmethod
+    def is_seekable(cls) -> bool: ...
+    @classmethod
+    def _compute(cls, file: File) -> None: ...
+    @classmethod
+    def _handle(cls, file: File) -> Any: ...
+    @classmethod
+    def _file_path(
+        cls, file: File, ensure: bool = ..., base: str | None = ...
+    ) -> str: ...