appier 1.34.12__py2.py3-none-any.whl → 1.35.1__py2.py3-none-any.whl

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/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/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/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/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/bus.pyi

@@ -1,8 +1,54 @@
 from threading import Thread
+from typing import Any, Callable, Self, Sequence
 
+from .base import App
 from .component import Component
 
-class Bus(Component): ...
-class MemoryBus(Bus): ...
-class RedisBus(Bus): ...
-class RedisListener(Thread): ...
+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/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/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/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/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/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/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: ...

appier/test/smtp.py

@@ -43,14 +43,11 @@ class SMTPTest(unittest.TestCase):
         mime["To"] = ", ".join([address_mime])
 
         result = mime.as_string()
-        self.assertEqual(
-            result,
-            'Content-Type: text/plain; charset="utf-8"\n\
+        self.assertEqual(result, 'Content-Type: text/plain; charset="utf-8"\n\
 MIME-Version: 1.0\n\
 Content-Transfer-Encoding: base64\n\
 Subject: Hello World\n\
 From: =?utf-8?q?Jo=C3=A3o_Magalh=C3=A3es?= <joamag@hive.pt>\n\
 To: =?utf-8?q?Jo=C3=A3o_Magalh=C3=A3es?= <joamag@hive.pt>\n\
 \n\
-SGVsbG8gV29ybGQ=\n',
-        )
+SGVsbG8gV29ybGQ=\n')

appier/test/storage.py

@@ -0,0 +1,305 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+# Hive Appier Framework
+# Copyright (c) 2008-2024 Hive Solutions Lda.
+#
+# This file is part of Hive Appier Framework.
+#
+# Hive Appier Framework is free software: you can redistribute it and/or modify
+# it under the terms of the Apache License as published by the Apache
+# Foundation, either version 2.0 of the License, or (at your option) any
+# later version.
+#
+# Hive Appier Framework is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# Apache License for more details.
+#
+# You should have received a copy of the Apache License along with
+# Hive Appier Framework. If not, see <http://www.apache.org/licenses/>.
+
+__author__ = "João Magalhães <joamag@hive.pt>"
+""" The author(s) of the module """
+
+__copyright__ = "Copyright (c) 2008-2024 Hive Solutions Lda."
+""" The copyright for the module """
+
+__license__ = "Apache License, Version 2.0"
+""" The license for the module """
+
+import os
+import shutil
+import tempfile
+import unittest
+
+import appier
+
+
+class StorageEngineTest(unittest.TestCase):
+    def test_is_seekable(self):
+        self.assertEqual(appier.StorageEngine.is_seekable(), False)
+
+    def test_is_stored(self):
+        self.assertEqual(appier.StorageEngine.is_stored(), False)
+
+
+class BaseEngineTest(unittest.TestCase):
+    def test_is_stored(self):
+        self.assertEqual(appier.BaseEngine.is_stored(), True)
+
+
+class FsEngineTest(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        if os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+
+    def test_store(self):
+        file_data = b"Hello World"
+        file = appier.File((b"test.txt", None, file_data))
+        file.engine = "fs"
+        file.params = {"file_path": os.path.join(self.temp_dir, "test.txt")}
+
+        appier.FsEngine.store(file)
+
+        file_path = os.path.join(self.temp_dir, "test.txt")
+        self.assertEqual(os.path.exists(file_path), True)
+
+        handle = open(file_path, "rb")
+        try:
+            data = handle.read()
+        finally:
+            handle.close()
+
+        self.assertEqual(data, file_data)
+
+    def test_load(self):
+        file_data = b"Hello World"
+        file_path = os.path.join(self.temp_dir, "test.txt")
+
+        handle = open(file_path, "wb")
+        try:
+            handle.write(file_data)
+        finally:
+            handle.close()
+
+        file = appier.File((b"test.txt", None, file_data))
+        file.engine = "fs"
+        file.params = {"file_path": file_path}
+
+        appier.FsEngine.load(file)
+
+        self.assertEqual(file.size, len(file_data))
+        self.assertEqual(file.hash != None, True)
+        self.assertEqual(file.etag != None, True)
+
+    def test_delete(self):
+        file_data = b"Hello World"
+        file_path = os.path.join(self.temp_dir, "test.txt")
+
+        handle = open(file_path, "wb")
+        try:
+            handle.write(file_data)
+        finally:
+            handle.close()
+
+        self.assertEqual(os.path.exists(file_path), True)
+
+        file = appier.File((b"test.txt", None, file_data))
+        file.engine = "fs"
+        file.params = {"file_path": file_path}
+
+        appier.FsEngine.delete(file)
+
+        self.assertEqual(os.path.exists(file_path), False)
+
+    def test_read(self):
+        file_data = b"Hello World"
+        file_path = os.path.join(self.temp_dir, "test.txt")
+
+        handle = open(file_path, "wb")
+        try:
+            handle.write(file_data)
+        finally:
+            handle.close()
+
+        file = appier.File((b"test.txt", None, file_data))
+        file.engine = "fs"
+        file.params = {"file_path": file_path}
+
+        data = appier.FsEngine.read(file)
+
+        self.assertEqual(data, file_data)
+
+    def test_read_size(self):
+        file_data = b"Hello World"
+        file_path = os.path.join(self.temp_dir, "test.txt")
+
+        handle = open(file_path, "wb")
+        try:
+            handle.write(file_data)
+        finally:
+            handle.close()
+
+        file = appier.File((b"test.txt", None, file_data))
+        file.engine = "fs"
+        file.params = {"file_path": file_path}
+
+        data = appier.FsEngine.read(file, size=5)
+
+        self.assertEqual(data, b"Hello")
+
+        data = appier.FsEngine.read(file, size=6)
+
+        self.assertEqual(data, b" World")
+
+        data = appier.FsEngine.read(file, size=6)
+
+        self.assertEqual(data, b"")
+
+    def test_seek(self):
+        file_data = b"Hello World"
+        file_path = os.path.join(self.temp_dir, "test.txt")
+
+        handle = open(file_path, "wb")
+        try:
+            handle.write(file_data)
+        finally:
+            handle.close()
+
+        file = appier.File((b"test.txt", None, file_data))
+        file.engine = "fs"
+        file.params = {"file_path": file_path}
+
+        appier.FsEngine.seek(file, offset=6)
+
+        data = appier.FsEngine.read(file)
+
+        self.assertEqual(data, b"World")
+
+    def test_cleanup(self):
+        file_data = b"Hello World"
+        file_path = os.path.join(self.temp_dir, "test.txt")
+
+        handle = open(file_path, "wb")
+        try:
+            handle.write(file_data)
+        finally:
+            handle.close()
+
+        file = appier.File((b"test.txt", None, file_data))
+        file.engine = "fs"
+        file.params = {"file_path": file_path}
+
+        appier.FsEngine._handle(file)
+
+        self.assertEqual(hasattr(file, "_handle"), True)
+
+        appier.FsEngine.cleanup(file)
+
+        self.assertEqual(hasattr(file, "_handle"), False)
+
+    def test_is_seekable(self):
+        self.assertEqual(appier.FsEngine.is_seekable(), True)
+
+    def test_file_path(self):
+        file = appier.File((b"test.txt", None, b"Hello World"))
+        file.engine = "fs"
+        file.params = {"file_path": os.path.join(self.temp_dir, "custom.txt")}
+
+        file_path = appier.FsEngine._file_path(file)
+
+        self.assertEqual(file_path, os.path.join(self.temp_dir, "custom.txt"))
+
+    def test_file_path_default(self):
+        file = appier.File((b"test.txt", None, b"Hello World"))
+        file.engine = "fs"
+
+        file_path = appier.FsEngine._file_path(file, base=self.temp_dir)
+
+        expected_path = os.path.join(self.temp_dir, file.guid)
+        self.assertEqual(file_path, expected_path)
+
+    def test_file_path_ensure(self):
+        sub_dir = os.path.join(self.temp_dir, "sub", "directory")
+        file = appier.File((b"test.txt", None, b"Hello World"))
+        file.engine = "fs"
+        file.params = {"file_path": os.path.join(sub_dir, "test.txt")}
+
+        self.assertEqual(os.path.exists(sub_dir), False)
+
+        file_path = appier.FsEngine._file_path(file, ensure=True)
+
+        self.assertEqual(os.path.exists(sub_dir), True)
+        self.assertEqual(file_path, os.path.join(sub_dir, "test.txt"))
+
+    def test_compute(self):
+        file_data = b"Hello World"
+        file_path = os.path.join(self.temp_dir, "test.txt")
+
+        handle = open(file_path, "wb")
+        try:
+            handle.write(file_data)
+        finally:
+            handle.close()
+
+        file = appier.File((b"test.txt", None, file_data))
+        file.engine = "fs"
+        file.params = {"file_path": file_path}
+
+        appier.FsEngine._compute(file)
+
+        self.assertEqual(file.size, len(file_data))
+        self.assertEqual(type(file.hash), str)
+        self.assertEqual(type(file.etag), str)
+        self.assertEqual(file.hash, file.etag)
+
+    def test_handle(self):
+        file_data = b"Hello World"
+        file_path = os.path.join(self.temp_dir, "test.txt")
+
+        handle = open(file_path, "wb")
+        try:
+            handle.write(file_data)
+        finally:
+            handle.close()
+
+        file = appier.File((b"test.txt", None, file_data))
+        file.engine = "fs"
+        file.params = {"file_path": file_path}
+
+        handle = appier.FsEngine._handle(file)
+
+        self.assertEqual(hasattr(file, "_handle"), True)
+        self.assertEqual(handle != None, True)
+        self.assertEqual(handle.closed, False)
+
+        appier.FsEngine.cleanup(file)
+
+    def test_integration(self):
+        file_data = b"Hello World"
+        file = appier.File((b"test.txt", None, file_data))
+        file.engine = "fs"
+        file.params = {"file_path": os.path.join(self.temp_dir, "test.txt")}
+
+        appier.FsEngine.store(file)
+
+        file2 = appier.File((b"test.txt", None, file_data))
+        file2.engine = "fs"
+        file2.params = {"file_path": os.path.join(self.temp_dir, "test.txt")}
+
+        appier.FsEngine.load(file2)
+
+        self.assertEqual(file2.size, len(file_data))
+
+        data = appier.FsEngine.read(file2)
+
+        self.assertEqual(data, file_data)
+
+        appier.FsEngine.delete(file2)
+
+        file_path = os.path.join(self.temp_dir, "test.txt")
+        self.assertEqual(os.path.exists(file_path), False)

appier/typesf.pyi

@@ -0,0 +1,104 @@
+from typing import Any, Iterator, Sequence
+
+FileLike = File | bytes | dict | tuple
+
+class AbstractType:
+    def json_v(self, *args, **kwargs) -> Any: ...
+    def map_v(self, *args, **kwargs) -> Any: ...
+
+class Type(AbstractType):
+    def __init__(self, value: Any): ...
+    def json_v(self, *args, **kwargs) -> Any: ...
+    def loads(self, value: Any) -> None: ...
+    def dumps(self) -> Any: ...
+
+class File(AbstractType):
+    data: bytes | None
+    data_b64: str | None
+    file: Any | None
+    hash: str | None
+    size: int
+    file_name: str
+    mime: str | None
+    etag: str | None
+    guid: str
+    params: dict[str, Any] | None
+    engine: str | None
+    def __init__(self, file: FileLike): ...
+    def __len__(self) -> int: ...
+    @classmethod
+    def open(cls, path: str) -> File: ...
+    def build_d(self, file_d: bytes, name: str = ...) -> None: ...
+    def build_b64(self, file_m: dict[str, Any]) -> None: ...
+    def build_t(self, file_t: tuple[str, str | None, bytes | None]) -> None: ...
+    def build_i(self, file: File) -> None: ...
+    def build_f(self, file: Any) -> None: ...
+    def read(self, size: int | None = ...) -> bytes | None: ...
+    def seek(self, offset: int | None = ...) -> None: ...
+    def delete(self) -> None: ...
+    def cleanup(self) -> None: ...
+    def save(self, path: str | None = ...) -> None: ...
+    def json_v(self, *args, **kwargs) -> dict[str, Any] | None: ...
+    def is_seekable(self) -> bool: ...
+    def is_stored(self) -> bool: ...
+    def is_valid(self) -> bool: ...
+    def is_empty(self) -> bool: ...
+    def _hash(self, data: bytes | None) -> str | None: ...
+    def _etag(self, data: bytes | None) -> str | None: ...
+    def _guid(self) -> str: ...
+    def _load(self, force: bool = ...) -> None: ...
+    def _store(self, force: bool = ...) -> None: ...
+    def _compute(self) -> None: ...
+    def _engine(self) -> Any: ...
+
+class Files(AbstractType):
+    _files: list[File]
+    def __init__(self, files: Files | Sequence[FileLike]): ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[File]: ...
+    def __getitem__(self, key: int) -> File: ...
+    def base(self) -> type[File]: ...
+    def build_i(self, files: Files) -> None: ...
+    def build_f(self, files: Any) -> None: ...
+    def json_v(self, *args, **kwargs) -> list[dict[str, Any]]: ...
+    def is_empty(self) -> bool: ...
+    def _load(self) -> None: ...
+
+class ImageFile(File):
+    width: int
+    height: int
+    format: str | None
+    kwargs: dict[str, Any]
+    def build_b64(self, file_m: dict[str, Any]) -> None: ...
+    def build_t(self, file_t: tuple[str, str | None, bytes | None]) -> None: ...
+    def build_i(self, file: File) -> None: ...
+    def build_f(self, file: Any) -> None: ...
+    def json_v(self, *args, **kwargs) -> dict[str, Any] | None: ...
+    def _ensure_all(self) -> None: ...
+    def _ensure_size(self) -> None: ...
+    def _ensure_mime(self) -> None: ...
+    def _ensure_kwargs(self) -> None: ...
+    def _size(self) -> tuple[int, int]: ...
+    def _size_image(self) -> tuple[int, int]: ...
+    def _size_pil(self) -> tuple[int, int]: ...
+    def _size_default(self) -> tuple[int, int]: ...
+    def _mime(self) -> tuple[str | None, str]: ...
+    def _mime_image(self) -> tuple[str | None, str]: ...
+    def _mime_pil(self) -> tuple[str | None, str]: ...
+    def _mime_default(self) -> tuple[str | None, str]: ...
+
+class ImageFiles(Files):
+    def base(self) -> type[ImageFile]: ...
+
+def image(
+    width: int | None = ..., height: int | None = ..., format: str = ..., **kwargs
+) -> type[ImageFile]: ...
+def images(
+    width: int | None = ..., height: int | None = ..., format: str = ..., **kwargs
+) -> type[ImageFiles]: ...
+
+class Reference(AbstractType): ...
+
+def reference(
+    target: Any, name: str | None = ..., dumpall: bool = ...
+) -> type[Reference]: ...

{appier-1.34.12.dist-info → appier-1.35.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.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.dist-info → appier-1.35.1.dist-info}/RECORD

@@ -1,7 +1,10 @@
-appier/__init__.py,sha256=YsoKeAEMyD5OWJWGe0x6fufIypPkKj4W5B0I31jqfjE,9449
+appier/__init__.py,sha256=3ruSiBwKkttroZWrtHHvMxxutjPJOvC9F-1qC2cfqvM,9510
 appier/amqp.py,sha256=etYxUlfaK27Og_9FJ6qCgNLSYhnz9XgVhIhSmD2ITW4,3852
+appier/amqp.pyi,sha256=vTsGOj0IjsRiRxdKfIAg4hTu2kHwPosZT24HlEIZfQ8,377
 appier/api.py,sha256=ZWRdjrEEUvCDcW_pp2BDgGCdNnS7tjdaZSzUfzSRzmQ,14778
-appier/asgi.py,sha256=Gubv7W8aLeLhaBxInE2Gc7Y2rxacbSlglAaKj25T6NY,12622
+appier/api.pyi,sha256=iStUeSkn1zwt8OHfVEeasWRmp_OjB897LuXRI_abR4g,4934
+appier/asgi.py,sha256=cjC3OUJ4XB3LzTdoJcM6aHvi-VpPQ2kjLwJOYL9YgMA,12959
+appier/asgi.pyi,sha256=PAbTl3yez12xz9p7VWzkjAn3doq6-DOZaQ9hdB6F32U,2641
 appier/async_neo.py,sha256=CqeVtKczXt3SZPvi0BYLujVTeN4i-sT8P1_0JPR5aiI,5448
 appier/async_old.py,sha256=83YuTmoZkLIeyNHLZusCXqxB_6onRmYdKJ-Sqd1Yi1E,9195
 appier/asynchronous.py,sha256=a1LQa3wbGMaXELhF7W71dRr1klPOj6x-ST9EInvPhtU,1757
@@ -9,14 +12,14 @@ appier/asynchronous.pyi,sha256=5CpLkpKcUq09woMOVYwpl24Pli0A8Xu6nXoT20xDQ-o,104
 appier/base.py,sha256=6OhCkyM8MNa-eOIXXaYOCui0xUbSPq07ZJGqcXiwVJ0,272193
 appier/base.pyi,sha256=CwhdTt6lVGiXsXQewN1kkISD1YRNPCUf9U8fxYUVI3E,2924
 appier/bus.py,sha256=GyzP_qkTRDNi-NA9XV0U3YnibUn2TWH0w2fGG_a0IWo,8086
-appier/bus.pyi,sha256=W6_MIBpvDq468wfT5XM2WpPuR3O49QiZMOSCdMsJWos,182
+appier/bus.pyi,sha256=jkTscpMMhiw4CrnUAhiGqNcxqengfaNFvdLNuOA_1i4,2267
 appier/cache.py,sha256=V1nhf4aHJpUlcFtxVsd-2tGCt1BarkxvHWwVwuhc4Ao,10689
 appier/cache.pyi,sha256=nrLCe6nAu_wLCa2juaALjPCQsNzIffrY_rb5MlGMrX0,176
 appier/common.py,sha256=fcECBvu-KcB9DImZzkpM_FA_PUqgCx0FKP4KHuOikYc,1313
 appier/component.py,sha256=I6xDQp0dmYOarOgbyrXIfXa1RAsVHttd8JjUub15U2M,2988
 appier/component.pyi,sha256=zKO71mWgi7I8QapKajZHoWznrLyofHigCT4gJvDY3G8,22
 appier/compress.py,sha256=o3E-at5DjpW2s3uOljEqqfLLyPzEU9cSXHFISk0sPvA,4699
-appier/config.py,sha256=pV6RXtu_f6U4449CyxL216fv4GjCjHUAOivqHAMaFfg,11405
+appier/config.py,sha256=6BkQHbj9kdRX-e3tJMuk1nXB4G-m5nANRmn3yFUSaaY,12089
 appier/controller.py,sha256=uKzPJnz6aqibspPKf4tfJRvVMtxdDv0RFb0ivcDoepU,2285
 appier/crypt.py,sha256=Kr7Rbil8_bUp-oE_c_Wu2LRgk8nmVb9ukCHSuXE7RSc,5874
 appier/data.py,sha256=inrM-kXXsx0jLqyetXMWdBuobZbAWBH1fnShV4NcW-Y,14764
@@ -28,16 +31,16 @@ appier/export.py,sha256=Sp1Z0wA7fxcJ2w2reNny67FN5Z44lCeEarQU_H8Nxcc,12105
 appier/extra.py,sha256=AwcpSg4qe7eVtNpaf5jy1hap8RcaoftGoNpGsFdvH90,1208
 appier/extra_neo.py,sha256=oI8qsjhA7tLieR1fSl67e2lAxDXkaD3xT4nkjvVFDz0,2342
 appier/extra_old.py,sha256=5mwfHIrz6Um7-QpXiqnEm_lXXpWhNvnMgPWIFVegItU,1991
-appier/geo.py,sha256=EEPh8oX7Uk7iert-XKt7HCw0swicc8lFAv7XFeQSbZ8,4877
+appier/geo.py,sha256=5XzHFCwfUBNFe7rkvPKWV9LWswcbfMn9tPS1q_Twk0s,5178
 appier/git.py,sha256=-neM2mxqlyiCNu17CpLyiz3RN7Ti6LtAx5L1tipxAGA,9785
-appier/graph.py,sha256=jSgu-ookILujLm4ivW14SymVmuI1nbjbVZMgRS2ehOg,4054
+appier/graph.py,sha256=9NdjTmlkUf6HbigBNB5ZvVKY2X7kafHhB8EXq7Xx-dM,4052
 appier/http.py,sha256=Ed-NL-VUGBCZtzIWMNZI0Z1iJ-lMbjLkF0WeH7nICdI,37662
 appier/legacy.py,sha256=o_oJ_2lqZELZKwkvfGt0aDam6ZSZiZiL7FYygNjrDbY,15881
 appier/log.py,sha256=jhV7ub5nZwrLzY7x-tZDJfb8tcsXu-ndWxxrCspBUdU,12825
 appier/meta.py,sha256=rgBLOjD6QU9CGYsbCQS3Fy4iY14uk1-Kd8ljkfmxxzc,7168
 appier/mock.py,sha256=WoWa67rb8qV_ogToQJCdT0R-rCw9RUY24EkA4bYR1G4,5800
 appier/model.py,sha256=0V_91vft3fMAFm5KzFILb-gdpoDqX6g66UGXxMYf_Jo,123021
-appier/model.pyi,sha256=prhI4tdSILryvLbDC65s4LwAt-LbkBtaTN5ltsotlOw,1897
+appier/model.pyi,sha256=m6qpkKge8MfyZLHHng0oM0VszO1XJTdy9_UgSpBfSAE,2369
 appier/model_a.py,sha256=c6XpG4oIelXNDK0uicsZ69-f6isUgmh5-29F61PZt9c,16176
 appier/mongo.py,sha256=rU3lRroXij6x17aKFBAbuiu8Cu2xOIP-DbDtI59Ln44,11535
 appier/observer.py,sha256=T0QpkxdkcNuEOZJdmJT5nFSJ2e-0VPbGveX5YKtt7mA,4519
@@ -55,9 +58,11 @@ appier/session.py,sha256=6rcwFdsu--7gFLr6mJJh3EFSZ_A3Oe8u7olAvTw2sUk,20380
 appier/session.pyi,sha256=JBYcT1wZ9mKBBk9iTw2GDJENB8PWFzxXjIr9oXKe85Q,239
 appier/settings.py,sha256=28tTRJIZ47iwXqUs6YtUoW7ntEVsp_0-QfONVDGA1sg,1136
 appier/smtp.py,sha256=5tW0dOEm03kejLoQyhRQFjgjYRd-jhb-VlhEKDb4Zn0,3434
-appier/storage.py,sha256=Qp_CMCDg85q35n9lggNVBZRWwlGrQ-nLYNj0W7Mnbec,7470
+appier/storage.py,sha256=qL8L_Db7vNMhK62Yd8r2qsLfnJ1eBKlbR8rfCSdEBsk,8351
+appier/storage.pyi,sha256=Q1-vbdwjgEnIhuDXS5lcpaLGNk7SL7opXq0-xBeCVA8,2034
 appier/structures.py,sha256=lwAEiz4k1O4bywGcfHvOvZJusN-lUwcviihR9aZLMtY,8883
 appier/typesf.py,sha256=XIYRQ2M7ErjvjB0SAu4Rkv3aYUOmWhqfZy3sUYyHtpM,37451
+appier/typesf.pyi,sha256=Y2cdZ2m2VKWam072hYQ12K_Uax2NKRCpoDkFXOBKuUI,3836
 appier/util.py,sha256=ogWRbNbyWcfVCU_pPzADXsMTwLi3Hd2wPOWzDw3K-IQ,84705
 appier/validation.py,sha256=dMxAELEKGo93ta2UpY88UQAbiKq61b9pHd5L5pAkECk,22800
 appier/res/static/css/base.css,sha256=J9zLozd57KoslAsrsj2a42glGTObxbkrrckR-W-_f2A,6127
@@ -89,14 +94,15 @@ appier/test/request.py,sha256=h3DdvhEMARpYTp7eRcJ3-qLQyG-a8PHqSnWY52BiOeU,8176
 appier/test/scheduler.py,sha256=j-0byKZZfD36EenJg8kVm55plZ5p1lTLz9GsOT0FDxE,8384
 appier/test/serialize.py,sha256=roX01n86AQfnPxzPVdIjdIUQWC_x0C_HE3hNgF37ci8,2120
 appier/test/session.py,sha256=KdiYLLB5autIEu1sHwOuYJXVd0y6RMPgg0ITBuRTMfA,4419
-appier/test/smtp.py,sha256=XJNa0ZTmabdrX8MfVMgcqBxabvBfHgIimvozdziP4_E,1826
+appier/test/smtp.py,sha256=xFFbtkxrIu97ChbKA5jRC1wmei2o2GdyLpg3r_nsnHs,1788
+appier/test/storage.py,sha256=GTrs-uo9-FyXbY_DC1gIKjRYi6y5ES0-q8XE1X13mUM,8932
 appier/test/structures.py,sha256=MRjUFRlnJi-i7YGWW5y792JbJwicNvOIzVAS220tgeQ,8367
 appier/test/tags.py,sha256=uf52pCsZL4-yp7i3Tk7F9T6aN4uYvYxbwcUUo-b7-0E,3861
 appier/test/typesf.py,sha256=KHumQFzx7wPZSCb8_mpIwobhIy2Fh_0XYviwPjXMbKI,9680
 appier/test/util.py,sha256=vfnleU3BUaqMs1mrpXjKom3V_zFOzrsjhmQ8sYp1GaQ,46668
 appier/test/validation.py,sha256=riOCsGKob1P5jnbcB5qGZ45ApimNAVS0byg9v_uUdrk,4952
-appier-1.34.12.dist-info/LICENSE,sha256=Pd-b5cKP4n2tFDpdx27qJSIq0d1ok0oEcGTlbtL6QMU,11560
-appier-1.34.12.dist-info/METADATA,sha256=rT3CvFXm-wQtf8GOQ3ePG0I-Jmuo0v9ngNkvlUfkfn8,1921
-appier-1.34.12.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
-appier-1.34.12.dist-info/top_level.txt,sha256=Z2e_Y1ya06a554WwQZkfNRiaaQxqsdaPtBzrck384Lo,7
-appier-1.34.12.dist-info/RECORD,,
+appier-1.35.1.dist-info/LICENSE,sha256=Pd-b5cKP4n2tFDpdx27qJSIq0d1ok0oEcGTlbtL6QMU,11560
+appier-1.35.1.dist-info/METADATA,sha256=Cd_g6pvs3QMSs3j2H35WjGeLwpc-m8F09jGh_C4Awkc,1920
+appier-1.35.1.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+appier-1.35.1.dist-info/top_level.txt,sha256=Z2e_Y1ya06a554WwQZkfNRiaaQxqsdaPtBzrck384Lo,7
+appier-1.35.1.dist-info/RECORD,,