faust-tools 1.0.5__py3-none-any.whl

faust_tools/decorators.py

@@ -0,0 +1,63 @@
+import inspect
+import logging
+import os
+from functools import wraps
+from typing import Callable, TypeVar
+
+from faust import App, Stream, TopicT
+from faust.agents import AgentT
+
+from .response import Response
+from .serializer import ReadStream, StreamSerializer, WriteStream
+
+_logger = logging.getLogger(__name__)
+
+_T = TypeVar("_T")
+
+StreamFunction = Callable[[StreamSerializer], Response]
+StreamDecorator = Callable[[StreamFunction], AgentT[_T]]
+
+
+def stream(
+    app: App, topic: TopicT, **kwargs
+) -> Callable[[StreamDecorator], AgentT[_T]]:
+    def decorator(func: StreamFunction) -> AgentT[_T]:
+        @wraps(func)
+        async def streaming(stream: Stream):
+            async for value in stream:
+                if not isinstance(value, StreamSerializer) or value.validate():
+                    continue
+
+                # Always call func correctly and ensure result is a Response
+                if inspect.iscoroutinefunction(func):
+                    result = await func(value)
+                else:
+                    result = func(value)
+                if not isinstance(result, Response):
+                    raise TypeError(
+                        f"Function {func.__name__} did not return a Response instance"
+                        f", got {type(result)}"
+                    )
+
+                response: Response = result
+                response.id = value.id
+                _logger.info(
+                    f"<{stream.channel}--{value.action}> :: {response.id} :: "
+                    f"{response.status.value} ({response.status.phrase})"
+                )
+                yield response.__dict__
+
+        agent_kwargs = {
+            "sink": [app.topic(os.environ["SERVICE_NAME"])],
+            **kwargs,
+        }
+        operation = os.getenv("SERVICE_OPERATION", "rw").lower()
+        if operation in ("r", "read") and issubclass(topic.value_type, ReadStream):
+            return app.agent(topic, **agent_kwargs)(streaming)
+        if operation in ("w", "write") and issubclass(topic.value_type, WriteStream):
+            return app.agent(topic, **agent_kwargs)(streaming)
+        if operation in ("rw", "read_write"):
+            return app.agent(topic, **agent_kwargs)(streaming)
+        return func
+
+    return decorator

faust_tools/fields.py

@@ -0,0 +1,18 @@
+from collections.abc import Iterable
+from typing import Any
+
+from faust.exceptions import ValidationError
+from faust.models import FieldDescriptor
+
+
+class ChoiceField(FieldDescriptor[str]):
+    def __init__(self, choices: list[str], **kwargs: Any) -> None:
+        self.choices = choices
+        # Must pass any custom args to init,
+        # so we pass the choices keyword argument also here.
+        super().__init__(choices=choices, **kwargs)
+
+    def validate(self, value: str) -> Iterable[ValidationError]:
+        if value not in self.choices:
+            choices = ", ".join(self.choices)
+            yield self.validation_error(f"{self.field} must be one of {choices}")

faust_tools/response.py

@@ -0,0 +1,18 @@
+from http import HTTPStatus
+
+
+class Response:
+    id: str | None
+    status: HTTPStatus
+    detail: dict | None
+
+    def __init__(
+        self,
+        *,
+        id: str | None = None,
+        status: HTTPStatus = HTTPStatus.OK,
+        detail: dict | None = None,
+    ):
+        self.id = id
+        self.status = status
+        self.detail = detail

faust_tools/serializer.py

@@ -0,0 +1,50 @@
+from collections.abc import Mapping
+
+import faust
+from faust.types.models import ModelT
+
+
+class StreamSerializer(faust.Record):
+    """
+    Main Stream Serializer
+    """
+
+    id: str
+    action: str
+    detail: dict | None = None
+
+    @classmethod
+    def from_data(
+        cls, data: Mapping, *, preferred_type: type[ModelT] | None = None
+    ) -> faust.Record:
+        attribute_type = preferred_type.__annotations__
+        record = super().from_data(data, preferred_type=preferred_type)
+        if record.detail and "detail" in attribute_type:
+            detail_type = attribute_type["detail"]
+            if (
+                isinstance(record.detail, list)
+                and hasattr(detail_type, "__args__")
+                and getattr(detail_type.__args__[0], "_auto_assign", None)
+            ):
+                for index, value in enumerate(record.detail):
+                    record.detail[index] = detail_type.__args__[0](**value)
+            elif isinstance(record.detail, dict) and getattr(
+                detail_type, "_auto_assign", None
+            ):
+                record.detail = detail_type(**record.detail)
+
+        return record
+
+
+class ReadStream(StreamSerializer):
+    """
+    Read Stream Serializer
+    """
+
+
+class WriteStream(StreamSerializer):
+    """
+    Write Stream Serializer
+    """
+
+    detail: dict | None

faust_tools-1.0.5.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: faust-tools
+Version: 1.0.5
+Summary: Faust Tools
+Author-email: Biszx <isares.br@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: faust-streaming>=0.11.3
+Dynamic: license-file
+
+# Faust Tools
+
+Make it easier to faust application
+
+## Feature
+
+### Decorator
+
+- stream
+
+### Field
+
+- ChoiceField
+
+### Serializer (Record)
+
+- ReadSerializer
+- Write Serializer

faust_tools-1.0.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+faust_tools/decorators.py,sha256=U5VMaXBcNeyrDezS9NC7paYLn8eH3jDhrIQ4LboJurc,2259
+faust_tools/fields.py,sha256=r5LvF7hxForXlsO9NSDcJsIerCa9QevasP9_qQW91Bk,678
+faust_tools/response.py,sha256=qj3Gz2djvhi_M2mMR-7m1bu-Xot-5xnRzgH2hJBNGFc,353
+faust_tools/serializer.py,sha256=-VjxQx43SCswe1TUIndcZsLQyBqbguDUOdZxiurLyuo,1347
+faust_tools-1.0.5.dist-info/licenses/LICENSE,sha256=ov-g_s6VBWsRTyUjaVCIomAmB8pgc_b2MOHD-0J5EzU,1070
+faust_tools-1.0.5.dist-info/METADATA,sha256=3_xuDR5cENx4BxPwNOku8XSuCA2EOfyYzg-2KgMcC4Y,454
+faust_tools-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+faust_tools-1.0.5.dist-info/top_level.txt,sha256=eQEbYFCnbkOgljK-mzI9djd5a5894rkr7lS8QLREVZ0,12
+faust_tools-1.0.5.dist-info/RECORD,,

faust_tools-1.0.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

faust_tools-1.0.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Trinity Roots
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

faust_tools-1.0.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+faust_tools