instant-python 0.0.1__py3-none-any.whl

instant_python/templates/boilerplate/event_bus/aggregate_root.py

@@ -0,0 +1,19 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event import DomainEvent
+
+
+class AggregateRoot:
+    _domain_events: list[DomainEvent]
+
+    def __init__(self) -> None:
+        self._domain_events = []
+
+    def record(self, event: DomainEvent) -> None:
+        self._domain_events.append(event)
+
+    def pull_domain_events(self) -> list[DomainEvent]:
+        recorded_domain_events = self._domain_events
+        self._domain_events = []
+
+        return recorded_domain_events

instant_python/templates/boilerplate/event_bus/domain_event.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, asdict
+
+
+@dataclass(frozen=True, kw_only=True)
+class DomainEvent(ABC):
+    id: str
+
+    @classmethod
+    @abstractmethod
+    def name(cls) -> str:
+        raise NotImplementedError
+
+    def to_dict(self) -> dict:
+        return asdict(self)

instant_python/templates/boilerplate/event_bus/domain_event_json_deserializer.py

@@ -0,0 +1,28 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+import json
+
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event import DomainEvent
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event_subscriber import (
+    DomainEventSubscriber,
+)
+from {{ source_name }}.{{ template_domain_import }}.exceptions.domain_event_type_not_found import (
+    DomainEventTypeNotFound,
+)
+
+
+class DomainEventJsonDeserializer:
+    _events_mapping: dict[str, type[DomainEvent]]
+
+    def __init__(self, subscriber: DomainEventSubscriber[DomainEvent]) -> None:
+        self._events_mapping = {
+            event.name(): event for event in subscriber.subscribed_to()
+        }
+
+    def deserialize(self, body: bytes) -> DomainEvent:
+        content = json.loads(body)
+        event_class = self._events_mapping.get(content["data"]["type"])
+
+        if not event_class:
+            raise DomainEventTypeNotFound(content["data"]["type"])
+
+        return event_class(**content["data"]["attributes"])

instant_python/templates/boilerplate/event_bus/domain_event_json_serializer.py

@@ -0,0 +1,17 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+import json
+
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event import DomainEvent
+
+
+class DomainEventJsonSerializer:
+    @staticmethod
+    def serialize(event: DomainEvent) -> str:
+        body = {
+            "data": {
+                "id": event.id,
+                "type": event.name(),
+                "attributes": event.to_dict(),
+            }
+        }
+        return json.dumps(body)

instant_python/templates/boilerplate/event_bus/domain_event_subscriber.py

@@ -0,0 +1,15 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+from abc import ABC, abstractmethod
+
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event import DomainEvent
+
+
+class DomainEventSubscriber[EventType: DomainEvent](ABC):
+    @staticmethod
+    @abstractmethod
+    def subscribed_to() -> list[type[EventType]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def on(self, event: EventType) -> None:
+        raise NotImplementedError

instant_python/templates/boilerplate/event_bus/event_bus.py

@@ -0,0 +1,10 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+from abc import ABC, abstractmethod
+
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event import DomainEvent
+
+
+class EventBus(ABC):
+    @abstractmethod
+    def publish(self, events: list[DomainEvent]) -> None:
+        raise NotImplementedError

instant_python/templates/boilerplate/event_bus/exchange_type.py

@@ -0,0 +1,7 @@
+from enum import StrEnum
+
+
+class ExchangeType(StrEnum):
+    TOPIC = "topic"
+    DIRECT = "direct"
+    FANOUT = "fanout"

instant_python/templates/boilerplate/event_bus/mock_event_bus.py

@@ -0,0 +1,18 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+from unittest.mock import AsyncMock
+
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event import DomainEvent
+from {{ source_name }}.{{ template_domain_import }}.event.event_bus import EventBus
+
+
+class MockEventBus(EventBus):
+
+	def __init__(self) -> None:
+		self._mock_publish = AsyncMock()
+
+	async def publish(self, events: list[DomainEvent]) -> None:
+		await self._mock_publish(events)
+
+	def should_have_published(self, event: DomainEvent) -> None:
+		self._mock_publish.assert_awaited_once_with([event])
+		self._mock_publish.reset_mock()

instant_python/templates/boilerplate/event_bus/rabbit_mq_configurer.py

@@ -0,0 +1,54 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+{% set template_infra_import = "shared.infra"|compute_base_path(template) %}
+
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event import DomainEvent
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event_subscriber import (
+    DomainEventSubscriber,
+)
+from {{ source_name }}.{{ template_infra_import }}.event.rabbit_mq.rabbit_mq_connection import (
+    RabbitMqConnection,
+)
+from {{ source_name }}.{{ template_infra_import }}.event.rabbit_mq.rabbit_mq_queue_formatter import (
+    RabbitMqQueueFormatter,
+)
+
+
+class RabbitMqConfigurer:
+    _queue_formatter: RabbitMqQueueFormatter
+    _connection: RabbitMqConnection
+
+    def __init__(
+        self, connection: RabbitMqConnection, queue_formatter: RabbitMqQueueFormatter
+    ) -> None:
+        self._queue_formatter = queue_formatter
+        self._connection = connection
+
+    def configure(
+        self, exchange_name: str, subscribers: list[DomainEventSubscriber[DomainEvent]]
+    ) -> None:
+        self._create_exchange(exchange_name)
+        for subscriber in subscribers:
+            self._create_and_bind_queue(subscriber, exchange_name)
+
+    def _create_exchange(self, exchange_name: str) -> None:
+        self._connection.create_exchange(name=exchange_name)
+
+    def _create_and_bind_queue(
+        self, subscriber: DomainEventSubscriber[DomainEvent], exchange_name: str
+    ) -> None:
+        routing_keys = self._get_queues_routing_keys_for(subscriber)
+        queue_name = self._queue_formatter.format(subscriber)
+        self._connection.create_queue(name=queue_name)
+
+        for routing_key in routing_keys:
+            self._connection.bind_queue_to_exchange(
+                queue_name=queue_name,
+                exchange_name=exchange_name,
+                routing_key=routing_key,
+            )
+
+    @staticmethod
+    def _get_queues_routing_keys_for(
+        subscriber: DomainEventSubscriber[DomainEvent],
+    ) -> list[str]:
+        return [event.name() for event in subscriber.subscribed_to()]

instant_python/templates/boilerplate/event_bus/rabbit_mq_connection.py

@@ -0,0 +1,77 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+{% set template_infra_import = "shared.infra"|compute_base_path(template) %}
+from typing import Callable
+
+import pika
+from pika.adapters.blocking_connection import BlockingChannel
+
+from {{ source_name }}.{{ template_domain_import }}.event.exchange_type import ExchangeType
+from {{ source_name }}.{{ template_domain_import }}.exceptions.rabbit_mq_connection_not_established_error import (
+    RabbitMqConnectionNotEstablishedError,
+)
+from {{ source_name }}.{{ template_infra_import }}.event.rabbit_mq.rabbit_mq_settings import (
+    RabbitMqSettings,
+)
+
+
+class RabbitMqConnection:
+    _channel: BlockingChannel | None
+    _connection: pika.BlockingConnection | None
+    _connection_settings: RabbitMqSettings
+
+    def __init__(self, connection_settings: RabbitMqSettings) -> None:
+        self._connection_settings = connection_settings
+        self._connection = None
+        self._channel = None
+        self.open_connection()
+
+    def open_connection(self) -> None:
+        credentials = pika.PlainCredentials(
+            username=self._connection_settings.user,
+            password=self._connection_settings.password,
+        )
+        self._connection = pika.BlockingConnection(
+            parameters=pika.ConnectionParameters(
+                host=self._connection_settings.host, credentials=credentials
+            )
+        )
+        self._channel = self._connection.channel()
+
+    def _ensure_channel_exists(self) -> None:
+        if self._channel is None:
+            raise RabbitMqConnectionNotEstablishedError
+
+    def create_exchange(self, name: str) -> None:
+        self._ensure_channel_exists()
+        self._channel.exchange_declare(exchange=name, exchange_type=ExchangeType.TOPIC)  # type: ignore
+
+    def publish(self, content: str, exchange: str, routing_key: str) -> None:
+        self._ensure_channel_exists()
+        self._channel.basic_publish(  # type: ignore
+            exchange=exchange,
+            routing_key=routing_key,
+            body=content,
+            properties=pika.BasicProperties(delivery_mode=pika.DeliveryMode.Persistent),
+        )
+
+    def bind_queue_to_exchange(
+        self, queue_name: str, exchange_name: str, routing_key: str
+    ) -> None:
+        self._ensure_channel_exists()
+        self._channel.queue_bind(  # type: ignore
+            exchange=exchange_name, queue=queue_name, routing_key=routing_key
+        )
+
+    def create_queue(self, name: str) -> None:
+        self._ensure_channel_exists()
+        self._channel.queue_declare(queue=name, durable=True)  # type: ignore
+
+    def consume(self, queue_name: str, callback: Callable) -> None:
+        self._ensure_channel_exists()
+        self._channel.basic_consume(  # type: ignore
+            queue=queue_name, on_message_callback=callback, auto_ack=False
+        )
+        self._channel.start_consuming()  # type: ignore
+
+    def close_connection(self) -> None:
+        self._channel.close()  # type: ignore

instant_python/templates/boilerplate/event_bus/rabbit_mq_consumer.py

@@ -0,0 +1,58 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+{% set template_infra_import = "shared.infra"|compute_base_path(template) %}
+from pika.adapters.blocking_connection import BlockingChannel
+from pika.spec import Basic, BasicProperties
+
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event import DomainEvent
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event_subscriber import (
+    DomainEventSubscriber,
+)
+from {{ source_name }}.{{ template_infra_import }}.event.domain_event_json_deserializer import (
+    DomainEventJsonDeserializer,
+)
+from {{ source_name }}.{{ template_infra_import }}.event.rabbit_mq.rabbit_mq_connection import (
+    RabbitMqConnection,
+)
+from {{ source_name }}.{{ template_infra_import }}.event.rabbit_mq.rabbit_mq_queue_formatter import (
+    RabbitMqQueueFormatter,
+)
+
+
+class RabbitMqConsumer:
+    _queue_formatter: RabbitMqQueueFormatter
+    _subscriber: DomainEventSubscriber[DomainEvent]
+    _client: RabbitMqConnection
+
+    def __init__(
+        self,
+        client: RabbitMqConnection,
+        subscriber: DomainEventSubscriber[DomainEvent],
+        queue_formatter: RabbitMqQueueFormatter,
+    ) -> None:
+        self._queue_formatter = queue_formatter
+        self._subscriber = subscriber
+        self._client = client
+        self._event_deserializer = DomainEventJsonDeserializer(subscriber=subscriber)
+
+    def _on_call(
+        self,
+        channel: BlockingChannel,
+        method: Basic.Deliver,
+        properties: BasicProperties,
+        body: bytes,
+    ) -> None:
+        event = self._deserialize_event(body)
+        self._subscriber.on(event)
+        channel.basic_ack(delivery_tag=method.delivery_tag)
+
+    def start_consuming(self) -> None:
+        self._client.consume(
+            queue_name=self._queue_formatter.format(self._subscriber),
+            callback=self._on_call,
+        )
+
+    def stop_consuming(self) -> None:
+        self._client.close_connection()
+
+    def _deserialize_event(self, body: bytes) -> DomainEvent:
+        return self._event_deserializer.deserialize(body)

instant_python/templates/boilerplate/event_bus/rabbit_mq_event_bus.py

@@ -0,0 +1,28 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+{% set template_infra_import = "shared.infra"|compute_base_path(template) %}
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event import DomainEvent
+from {{ source_name }}.{{ template_domain_import }}.event.event_bus import EventBus
+from {{ source_name }}.{{ template_infra_import }}.event.domain_event_json_serializer import (
+    DomainEventJsonSerializer,
+)
+from {{ source_name }}.{{ template_infra_import }}.event.rabbit_mq.rabbit_mq_connection import (
+    RabbitMqConnection,
+)
+
+
+class RabbitMqEventBus(EventBus):
+    def __init__(self, client: RabbitMqConnection, exchange_name: str) -> None:
+        self._client = client
+        self._exchange_name = exchange_name
+        self._event_serializer = DomainEventJsonSerializer()
+
+    def publish(self, events: list[DomainEvent]) -> None:
+        for event in events:
+            self._client.publish(
+                content=self._serialize_event(event),
+                exchange=self._exchange_name,
+                routing_key=event.name(),
+            )
+
+    def _serialize_event(self, event: DomainEvent) -> str:
+        return self._event_serializer.serialize(event)

instant_python/templates/boilerplate/event_bus/rabbit_mq_queue_formatter.py

@@ -0,0 +1,22 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+import re
+
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event import DomainEvent
+from {{ source_name }}.{{ template_domain_import }}.event.domain_event_subscriber import (
+    DomainEventSubscriber,
+)
+
+
+class RabbitMqQueueFormatter:
+    _bounded_context: str
+    CAMEL_CASE_TO_SNAKE_CASE_PATTERN = r"(?<!^)(?=[A-Z])"
+
+    def __init__(self, bounded_context: str) -> None:
+        self._bounded_context = bounded_context
+
+    def format(self, subscriber: DomainEventSubscriber[DomainEvent]) -> str:
+        unformatted_subscriber_name = subscriber.__class__.__name__
+        formatted_subscriber_name = re.sub(
+            self.CAMEL_CASE_TO_SNAKE_CASE_PATTERN, "_", unformatted_subscriber_name
+        ).lower()
+        return f"{self._bounded_context}.{formatted_subscriber_name}"

instant_python/templates/boilerplate/event_bus/rabbit_mq_settings.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass(kw_only=True)
+class RabbitMqSettings:
+    user: str
+    password: str
+    host: str

instant_python/templates/boilerplate/exceptions/domain_error.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+
+class DomainError(Exception, ABC):
+	@property
+	@abstractmethod
+	def type(self) -> str: ...
+
+	@property
+	@abstractmethod
+	def message(self) -> str: ...
+
+	def to_dict(self) -> dict:
+		return {
+			"type": self.type,
+			"message": self.message,
+		}

instant_python/templates/boilerplate/exceptions/domain_event_type_not_found_error.py

@@ -0,0 +1,17 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+from {{ source_name }}.{{ template_domain_import }}.exceptions.domain_error import DomainError
+
+
+class DomainEventTypeNotFound(DomainError):
+	def __init__(self, name: str) -> None:
+		self._message = f"Event type {name} not found among subscriber."
+		self._type = "domain_event_type_not_found"
+		super().__init__(self._message)
+
+	@property
+	def type(self) -> str:
+		return self._type
+
+	@property
+	def message(self) -> str:
+		return self._message

instant_python/templates/boilerplate/exceptions/incorrect_value_type_error.py

@@ -0,0 +1,21 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+from typing import TypeVar
+
+from {{ source_name }}.{{ template_domain_import }}.exceptions.domain_error import DomainError
+
+T = TypeVar("T")
+
+
+class IncorrectValueTypeError(DomainError):
+    def __init__(self, value: T) -> None:
+        self._message = f"Value '{value}' is not of type {type(value).__name__}"
+        self._type = "incorrect_value_type"
+        super().__init__(self._message)
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @property
+    def message(self) -> str:
+        return self._message

instant_python/templates/boilerplate/exceptions/invalid_id_format_error.py

@@ -0,0 +1,17 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+from {{ source_name }}.{{ template_domain_import }}.exceptions.domain_error import DomainError
+
+
+class InvalidIdFormatError(DomainError):
+	def __init__(self) -> None:
+		self._message = "User id must be a valid UUID"
+		self._type = "invalid_id_format"
+		super().__init__(self._message)
+
+	@property
+	def type(self) -> str:
+		return self._type
+
+	@property
+	def message(self) -> str:
+		return self._message

instant_python/templates/boilerplate/exceptions/invalid_negative_value_error.py

@@ -0,0 +1,17 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+from {{ source_name }}.{{ template_domain_import }}.exceptions.domain_error import DomainError
+
+
+class InvalidNegativeValueError(DomainError):
+    def __init__(self, value: int) -> None:
+        self._message = f"Invalid negative value: {value}"
+        self._type = "invalid_negative_value"
+        super().__init__(self._message)
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @property
+    def message(self) -> str:
+        return self._message

instant_python/templates/boilerplate/exceptions/required_value_error.py

@@ -0,0 +1,17 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+from {{ source_name }}.{{ template_domain_import }}.exceptions.domain_error import DomainError
+
+
+class RequiredValueError(DomainError):
+    def __init__(self) -> None:
+        self._message = "Value is required, can't be None"
+        self._type = "required_value"
+        super().__init__(self._message)
+
+    @property
+    def type(self) -> str:
+        return self._type
+
+    @property
+    def message(self) -> str:
+        return self._message

instant_python/templates/boilerplate/fastapi/application.py

@@ -0,0 +1,25 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+{% set template_infra_import = "shared.infra"|compute_base_path(template) %}
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+{% if template == template_types.STANDARD %}
+from {{ source_name }}.api.lifespan import lifespan
+{% else %}
+from {{ source_name }}.delivery.api.lifespan import lifespan
+{% endif %}
+from {{ source_name }}.{{ template_infra_import }}.http.http_response import HttpResponse
+from {{ source_name }}.{{ template_infra_import }}.http.status_code import StatusCode
+from {{ source_name }}.{{ template_domain_import }}.exceptions.domain_error import DomainError
+
+app = FastAPI(lifespan=lifespan)
+
+
+@app.exception_handler(Exception)
+async def unexpected_exception_handler(_: Request, exc: Exception) -> JSONResponse:
+	return HttpResponse.internal_error(exc)
+
+
+@app.exception_handler(DomainError)
+async def domain_error_handler(_: Request, exc: DomainError) -> JSONResponse:
+	return HttpResponse.domain_error(exc, status_code=StatusCode.BAD_REQUEST)

instant_python/templates/boilerplate/fastapi/http_response.py

@@ -0,0 +1,45 @@
+{% set template_domain_import = "shared.domain"|compute_base_path(template) %}
+{% set template_infra_import = "shared.infra"|compute_base_path(template) %}
+from fastapi.responses import JSONResponse
+
+from {{ source_name }}.{{ template_domain_import }}.exceptions.domain_error import DomainError
+from {{ source_name }}.{{ template_infra_import }}.http.status_code import StatusCode
+from {{ source_name }}.{{ template_infra_import }}.log.logger import create_logger
+
+logger = create_logger("logger")
+
+
+class HttpResponse:
+	@staticmethod
+	def domain_error(error: DomainError, status_code: StatusCode) -> JSONResponse:
+		logger.error(
+			"error - domain error",
+			extra={"extra": {"error": error.to_dict(), "status_code": status_code}},
+		)
+		return JSONResponse(content={"error": error.to_dict()}, status_code=status_code)
+
+	@staticmethod
+	def internal_error(error: Exception) -> JSONResponse:
+		logger.error(
+			"error - internal server error",
+			extra={
+				"extra": {"error": str(error)},
+				"status_code": StatusCode.INTERNAL_SERVER_ERROR,
+			},
+		)
+		return JSONResponse(
+			content={"error": "Internal server error"},
+			status_code=StatusCode.INTERNAL_SERVER_ERROR,
+		)
+
+	@staticmethod
+	def created(resource: str) -> JSONResponse:
+		logger.info(
+			f"resource - {resource}",
+			extra={"extra": {"status_code": StatusCode.CREATED}},
+		)
+		return JSONResponse(content={}, status_code=StatusCode.CREATED)
+
+	@staticmethod
+	def ok(content: dict) -> JSONResponse:
+		return JSONResponse(content=content, status_code=StatusCode.OK)

instant_python/templates/boilerplate/fastapi/lifespan.py

@@ -0,0 +1,14 @@
+{% set template_infra_import = "shared.infra"|compute_base_path(template) %}
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from {{ source_name }}.{{ template_infra_import }}.alembic_migrator import AlembicMigrator
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
+	migrator = AlembicMigrator()
+	await migrator.migrate()
+	yield

instant_python/templates/boilerplate/fastapi/status_code.py

@@ -0,0 +1,9 @@
+from enum import IntEnum
+
+
+class StatusCode(IntEnum):
+	OK = 200
+	CREATED = 201
+	BAD_REQUEST = 400
+	NOT_FOUND = 404
+	INTERNAL_SERVER_ERROR = 500

instant_python/templates/boilerplate/github/action.yml

@@ -0,0 +1,22 @@
+name: Install Python and setup environment
+
+inputs:
+  python-version:
+    description: 'The version of Python to use'
+    required: false
+    default: {{ python_version }}
+outputs: {}
+runs:
+  using: composite
+  steps:
+    - uses: actions/setup-python@v5
+      with:
+        python-version: {% raw %}${{ inputs.python-version }}{% endraw %}
+
+    - name: Install dependency manager
+      run: python -m pip install {{ dependency_manager }}
+      shell: bash
+    - name: Install dependencies
+      run: {% if dependency_manager == "uv" %}uv sync --all-groups{% elif dependency_manager == "pdm" %}pdm install {% endif %}
+
+      shell: bash