snakeboot 0.2.0__tar.gz → 0.3.0__tar.gz

{snakeboot-0.2.0 → snakeboot-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snakeboot
-Version: 0.2.0
+Version: 0.3.0
 Summary: Spring Boot ergonomics for hexagonal Python: @transactional, application events, a component scan, typed configuration with profiles and singleton REST controllers on Django Ninja, wired by wireup.
 Keywords: spring-boot,hexagonal-architecture,ddd,django,django-ninja,wireup,dependency-injection,transactional
 Author: Wouter Deketelaere
@@ -48,7 +48,8 @@ classes you can read in an afternoon, and none of them knows anything about your
 | `ApplicationEventPublisher`, `@event_listener`, `@transactional_event_listener` | the same names | wireup |
 | `@rest_controller`, `@route.get`, `@rest_controller_advice`, `@exception_handler` | `@RestController`, `@GetMapping`, `@RestControllerAdvice`, `@ExceptionHandler` | `snakeboot[ninja]` |
 | `DjangoAtomicTransactionManager` | `PlatformTransactionManager` for JDBC | `snakeboot[django]` |
-| `@configuration_properties`, `load_configuration`, `application-<profile>.toml` | `@ConfigurationProperties`, `@EnableConfigurationProperties`, profiles | `snakeboot[configuration]` |
+| `@configuration_properties`, `Section`, `load_configuration`, `application-<profile>.toml` | `@ConfigurationProperties`, `@EnableConfigurationProperties`, profiles | `snakeboot[configuration]` |
+| `DjangoProperties`, `DatabaseProperties`, `CacheProperties` | `server.*`, `spring.datasource.*`, `spring.data.redis.*` | `snakeboot[configuration]` |
 | `RecordingTransactionManager`, `declared_classes` | spring-test | nothing |
 
 The transaction, component scan and testing packages import nothing but the standard library,
@@ -76,22 +77,23 @@ class MyApplication: ...
 WIREUP = WireupSettings(injectables=[*ComponentScan.of(MyApplication).module_names()], auto_inject_views=False)
 ```
 
-**Typed configuration.** A Pydantic model is bound to one table of `application.toml`, like
-`@ConfigurationProperties`. Settings lists the sections once, like `@EnableConfigurationProperties`;
-every section then reaches wireup by its type.
+**Typed configuration.** A `Section` (a frozen Pydantic model that refuses unknown keys) is bound to one
+table of `application.toml`, like `@ConfigurationProperties`. Settings lists the sections once, like
+`@EnableConfigurationProperties`; every section then reaches wireup by its type. The sections Django itself
+needs come with snakeboot: `DjangoProperties` (`[django]`), `DatabaseProperties` (`[database]`, PostgreSQL) and
+`CacheProperties` (`[cache]`, Redis).
 
 ```python
 @configuration_properties("chatbot")
-class ChatbotProperties(BaseModel):
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
+class ChatbotProperties(Section):
     model: str  # no default: the value is in application.toml
-    llm: LanguageModelProperties  # a nested model is the table [chatbot.llm]
+    llm: LanguageModelProperties  # a nested Section is the table [chatbot.llm]
 
 
 # settings.py
-CONFIGURATION = load_configuration(DjangoProperties, ChatbotProperties, package="myapp")
+CONFIGURATION = load_configuration(DjangoProperties, DatabaseProperties, ChatbotProperties, package="myapp")
 SECRET_KEY = CONFIGURATION.get(DjangoProperties).secret_key.get_secret_value()
+DATABASES = {"default": CONFIGURATION.get(DatabaseProperties).as_django_database()}
 WIREUP = WireupSettings(injectables=[*ComponentScan.of(MyApplication).module_names(), *CONFIGURATION.injectables()])
 ```
 

{snakeboot-0.2.0 → snakeboot-0.3.0}/README.md

@@ -13,7 +13,8 @@ classes you can read in an afternoon, and none of them knows anything about your
 | `ApplicationEventPublisher`, `@event_listener`, `@transactional_event_listener` | the same names | wireup |
 | `@rest_controller`, `@route.get`, `@rest_controller_advice`, `@exception_handler` | `@RestController`, `@GetMapping`, `@RestControllerAdvice`, `@ExceptionHandler` | `snakeboot[ninja]` |
 | `DjangoAtomicTransactionManager` | `PlatformTransactionManager` for JDBC | `snakeboot[django]` |
-| `@configuration_properties`, `load_configuration`, `application-<profile>.toml` | `@ConfigurationProperties`, `@EnableConfigurationProperties`, profiles | `snakeboot[configuration]` |
+| `@configuration_properties`, `Section`, `load_configuration`, `application-<profile>.toml` | `@ConfigurationProperties`, `@EnableConfigurationProperties`, profiles | `snakeboot[configuration]` |
+| `DjangoProperties`, `DatabaseProperties`, `CacheProperties` | `server.*`, `spring.datasource.*`, `spring.data.redis.*` | `snakeboot[configuration]` |
 | `RecordingTransactionManager`, `declared_classes` | spring-test | nothing |
 
 The transaction, component scan and testing packages import nothing but the standard library,
@@ -41,22 +42,23 @@ class MyApplication: ...
 WIREUP = WireupSettings(injectables=[*ComponentScan.of(MyApplication).module_names()], auto_inject_views=False)
 ```
 
-**Typed configuration.** A Pydantic model is bound to one table of `application.toml`, like
-`@ConfigurationProperties`. Settings lists the sections once, like `@EnableConfigurationProperties`;
-every section then reaches wireup by its type.
+**Typed configuration.** A `Section` (a frozen Pydantic model that refuses unknown keys) is bound to one
+table of `application.toml`, like `@ConfigurationProperties`. Settings lists the sections once, like
+`@EnableConfigurationProperties`; every section then reaches wireup by its type. The sections Django itself
+needs come with snakeboot: `DjangoProperties` (`[django]`), `DatabaseProperties` (`[database]`, PostgreSQL) and
+`CacheProperties` (`[cache]`, Redis).
 
 ```python
 @configuration_properties("chatbot")
-class ChatbotProperties(BaseModel):
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
+class ChatbotProperties(Section):
     model: str  # no default: the value is in application.toml
-    llm: LanguageModelProperties  # a nested model is the table [chatbot.llm]
+    llm: LanguageModelProperties  # a nested Section is the table [chatbot.llm]
 
 
 # settings.py
-CONFIGURATION = load_configuration(DjangoProperties, ChatbotProperties, package="myapp")
+CONFIGURATION = load_configuration(DjangoProperties, DatabaseProperties, ChatbotProperties, package="myapp")
 SECRET_KEY = CONFIGURATION.get(DjangoProperties).secret_key.get_secret_value()
+DATABASES = {"default": CONFIGURATION.get(DatabaseProperties).as_django_database()}
 WIREUP = WireupSettings(injectables=[*ComponentScan.of(MyApplication).module_names(), *CONFIGURATION.injectables()])
 ```
 

{snakeboot-0.2.0 → snakeboot-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "snakeboot"
-version = "0.2.0"
+version = "0.3.0"
 description = "Spring Boot ergonomics for hexagonal Python: @transactional, application events, a component scan, typed configuration with profiles and singleton REST controllers on Django Ninja, wired by wireup."
 readme = "README.md"
 license = "MIT"

{snakeboot-0.2.0 → snakeboot-0.3.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "snakeboot"
-version = "0.2.0"
+version = "0.3.0"
 description = "Spring Boot ergonomics for hexagonal Python: @transactional, application events, a component scan, typed configuration with profiles and singleton REST controllers on Django Ninja, wired by wireup."
 readme = "README.md"
 license = "MIT"

{snakeboot-0.2.0 → snakeboot-0.3.0}/src/snakeboot/configuration/__init__.py

@@ -1,8 +1,7 @@
 """Technical library: typed configuration from application.toml, one profile and the environment.
 
     @configuration_properties("chatbot")         # @ConfigurationProperties(prefix = "chatbot")
-    class ChatbotProperties(BaseModel):
-        model_config = ConfigDict(extra="forbid", frozen=True)
+    class ChatbotProperties(Section):
         model: str                               # no default: the value is in application.toml
 
     # in settings.py, like @EnableConfigurationProperties({DjangoProperties.class, ChatbotProperties.class}):
@@ -12,24 +11,31 @@
 
 The values come from `application.toml` in the package, then `application-<profile>.toml` when
 SNAKEBOOT_PROFILE is set, then environment variables such as CHATBOT__MODEL; nothing else.
+`DjangoProperties`, `DatabaseProperties` and `CacheProperties` are the sections Django itself needs.
 """
 
+from snakeboot.configuration.cache_properties import CacheProperties
 from snakeboot.configuration.configuration import Configuration
 from snakeboot.configuration.configuration_errors import (
     ConfigurationFileNotFoundError,
     InvalidConfigurationPropertiesError,
 )
 from snakeboot.configuration.configuration_properties import configuration_properties
+from snakeboot.configuration.database_properties import DatabaseProperties
 from snakeboot.configuration.django_properties import DjangoProperties
 from snakeboot.configuration.load_configuration import BASE_FILE, PROFILE_VARIABLE, load_configuration
+from snakeboot.configuration.section import Section
 
 __all__ = [
     "BASE_FILE",
     "PROFILE_VARIABLE",
+    "CacheProperties",
     "Configuration",
     "ConfigurationFileNotFoundError",
+    "DatabaseProperties",
     "DjangoProperties",
     "InvalidConfigurationPropertiesError",
+    "Section",
     "configuration_properties",
     "load_configuration",
 ]

snakeboot-0.3.0/src/snakeboot/configuration/cache_properties.py

@@ -0,0 +1,16 @@
+from snakeboot.configuration.configuration_properties import configuration_properties
+from snakeboot.configuration.section import Section
+
+
+@configuration_properties("cache")
+class CacheProperties(Section):
+    """The section `[cache]`: the Redis that backs Django's cache, like Spring Boot's `spring.data.redis.*`.
+
+    CACHES = {"default": CONFIGURATION.get(CacheProperties).as_django_cache()}
+    """
+
+    redis_url: str
+
+    def as_django_cache(self) -> dict[str, str]:
+        """The entry of Django's `CACHES` setting."""
+        return {"BACKEND": "django.core.cache.backends.redis.RedisCache", "LOCATION": self.redis_url}

snakeboot-0.3.0/src/snakeboot/configuration/database_properties.py

@@ -0,0 +1,29 @@
+from pydantic import SecretStr
+
+from snakeboot.configuration.configuration_properties import configuration_properties
+from snakeboot.configuration.section import Section
+
+
+@configuration_properties("database")
+class DatabaseProperties(Section):
+    """The section `[database]`: the PostgreSQL database of the service, like Spring Boot's `spring.datasource.*`.
+
+    DATABASES = {"default": CONFIGURATION.get(DatabaseProperties).as_django_database()}
+    """
+
+    host: str
+    port: int
+    name: str
+    user: str
+    password: SecretStr
+
+    def as_django_database(self) -> dict[str, str]:
+        """The entry of Django's `DATABASES` setting."""
+        return {
+            "ENGINE": "django.db.backends.postgresql",
+            "HOST": self.host,
+            "PORT": str(self.port),
+            "NAME": self.name,
+            "USER": self.user,
+            "PASSWORD": self.password.get_secret_value(),
+        }

{snakeboot-0.2.0 → snakeboot-0.3.0}/src/snakeboot/configuration/django_properties.py

@@ -1,19 +1,18 @@
 from typing import Literal
 
-from pydantic import BaseModel, ConfigDict, SecretStr
+from pydantic import SecretStr
 
 from snakeboot.configuration.configuration_properties import configuration_properties
+from snakeboot.configuration.section import Section
 
 
 @configuration_properties("django")
-class DjangoProperties(BaseModel):
+class DjangoProperties(Section):
     """The section `[django]`: what settings.py hands to Django itself, like Spring Boot's `server.*` properties.
 
     `secret_key` is a SecretStr, so it never shows in a log or a traceback; settings.py unwraps it once.
     """
 
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
     secret_key: SecretStr
     debug: bool
     allowed_hosts: tuple[str, ...]

{snakeboot-0.2.0 → snakeboot-0.3.0}/src/snakeboot/configuration/properties_rules.py

@@ -42,8 +42,8 @@ def _models_named_by(annotation: object) -> Iterator[type[BaseModel]]:
 def _refuse_open_model(model: type[BaseModel]) -> None:
     if model.model_config.get("extra") != "forbid" or model.model_config.get("frozen") is not True:
         raise InvalidConfigurationPropertiesError(
-            f'{model.__name__} must declare model_config = ConfigDict(extra="forbid", frozen=True): an unknown '
-            "key is a typo that must stop the start, and the configuration does not change while running."
+            f"{model.__name__} must extend Section (extra='forbid', frozen=True): an unknown key is a typo that "
+            "must stop the start, and the configuration does not change while running."
         )
 
 

snakeboot-0.3.0/src/snakeboot/configuration/section.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, ConfigDict
+
+
+class Section(BaseModel):
+    """A table of application.toml as a class: a frozen Pydantic model that refuses unknown keys.
+
+    Every section and every table nested in it extends `Section`, so a typo in a key stops the start and a value
+    cannot change while the application runs. Give no field a default: every value is written in application.toml
+    or in a profile, where everyone can read it.
+    """
+
+    model_config = ConfigDict(extra="forbid", frozen=True)