platzky 0.4.1__tar.gz → 1.0.0__tar.gz

platzky-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Platzky Contributors
+
+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.

{platzky-0.4.1 → platzky-1.0.0}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: platzky
-Version: 0.4.1
+Version: 1.0.0
 Summary: Not only blog engine
 License: MIT
+License-File: LICENSE
 Requires-Python: >=3.10,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
@@ -11,6 +12,8 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: docs
+Provides-Extra: telemetry
 Requires-Dist: Flask (==3.0.3)
 Requires-Dist: Flask-Babel (>=4.0.0,<5.0.0)
 Requires-Dist: Flask-Minify (>=0.42,<0.43)
@@ -21,9 +24,17 @@ Requires-Dist: deprecation (>=2.1.0,<3.0.0)
 Requires-Dist: google-cloud-storage (>=2.5.0,<3.0.0)
 Requires-Dist: gql (>=3.4.0,<4.0.0)
 Requires-Dist: humanize (>=4.9.0,<5.0.0)
+Requires-Dist: myst-parser (>=4.0.0,<5.0.0) ; extra == "docs"
+Requires-Dist: opentelemetry-api (>=1.27.0,<2.0.0) ; extra == "telemetry"
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (>=1.27.0,<2.0.0) ; extra == "telemetry"
+Requires-Dist: opentelemetry-instrumentation-flask (>=0.48b0,<0.49) ; extra == "telemetry"
+Requires-Dist: opentelemetry-sdk (>=1.27.0,<2.0.0) ; extra == "telemetry"
 Requires-Dist: pydantic (>=2.7.1,<3.0.0)
 Requires-Dist: pygithub (>=2.6.1,<3.0.0)
 Requires-Dist: pymongo (>=4.7.0,<5.0.0)
+Requires-Dist: sphinx (>=8.0.0,<9.0.0) ; extra == "docs"
+Requires-Dist: sphinx-rtd-theme (>=3.0.0,<4.0.0) ; extra == "docs"
+Requires-Dist: tomli (>=2.0.0,<3.0.0) ; extra == "docs"
 Description-Content-Type: text/markdown
 
 ![Github Actions](https://github.com/platzky/platzky/actions/workflows/tests.yml/badge.svg?event=push&branch=main)

platzky-1.0.0/platzky/config.py

@@ -0,0 +1,207 @@
+"""Configuration module for Platzky application.
+
+This module defines all configuration models and parsing logic for the application.
+"""
+
+import sys
+import typing as t
+
+import yaml
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from .db.db import DBConfig
+from .db.db_loader import get_db_module
+
+
+class StrictBaseModel(BaseModel):
+    """Base model with immutable (frozen) configuration."""
+
+    model_config = ConfigDict(frozen=True)
+
+
+class LanguageConfig(StrictBaseModel):
+    """Configuration for a single language.
+
+    Attributes:
+        name: Display name of the language
+        flag: Flag icon code (country code)
+        country: Country code
+        domain: Optional domain specific to this language
+    """
+
+    name: str = Field(alias="name")
+    flag: str = Field(alias="flag")
+    country: str = Field(alias="country")
+    domain: t.Optional[str] = Field(default=None, alias="domain")
+
+
+Languages = dict[str, LanguageConfig]
+LanguagesMapping = t.Mapping[str, t.Mapping[str, str]]
+
+# Validation error messages
+_INVALID_ENDPOINT_FORMAT_MSG = (
+    "Invalid endpoint: '{}'. Must be host:port or [http|https]://host[:port]"
+)
+_INVALID_ENDPOINT_SCHEME_MSG = "Invalid endpoint scheme: '{}'. Must be http or https"
+_MISSING_HOSTNAME_MSG = "Invalid endpoint: '{}'. Missing hostname"
+
+
+def languages_dict(languages: Languages) -> LanguagesMapping:
+    """Convert Languages configuration to a mapping dictionary.
+
+    Excludes None values to align with type signature.
+
+    Args:
+        languages: Dictionary of language configurations
+
+    Returns:
+        Mapping of language codes to their configuration dictionaries (excludes None values)
+    """
+    return {
+        name: {k: v for k, v in lang.model_dump().items() if v is not None}
+        for name, lang in languages.items()
+    }
+
+
+class TelemetryConfig(StrictBaseModel):
+    """OpenTelemetry configuration for application tracing.
+
+    Attributes:
+        enabled: Enable or disable telemetry tracing
+        endpoint: OTLP gRPC endpoint (e.g., localhost:4317 or http://localhost:4317)
+        console_export: Export traces to console for debugging
+        timeout: Timeout in seconds for exporter (default: 10)
+        deployment_environment: Deployment environment (e.g., production, staging, dev)
+        service_instance_id: Service instance ID (auto-generated if not provided)
+        flush_on_request: Flush spans after each request (default: True, may impact latency)
+        flush_timeout_ms: Timeout in milliseconds for per-request flush (default: 5000)
+    """
+
+    enabled: bool = Field(default=False, alias="enabled")
+    endpoint: t.Optional[str] = Field(default=None, alias="endpoint")
+    console_export: bool = Field(default=False, alias="console_export")
+    timeout: int = Field(default=10, alias="timeout", gt=0)
+    deployment_environment: t.Optional[str] = Field(default=None, alias="deployment_environment")
+    service_instance_id: t.Optional[str] = Field(default=None, alias="service_instance_id")
+    flush_on_request: bool = Field(default=True, alias="flush_on_request")
+    flush_timeout_ms: int = Field(default=5000, alias="flush_timeout_ms", gt=0)
+
+    @field_validator("endpoint")
+    @classmethod
+    def validate_endpoint(cls, v: t.Optional[str]) -> t.Optional[str]:
+        """Validate endpoint URL format.
+
+        Accepts OTLP/gRPC spec-compliant formats:
+        - host:port (e.g., localhost:4317)
+        - http://host[:port]
+        - https://host[:port]
+
+        Note: grpc:// scheme is NOT supported per OTLP spec and will be rejected.
+        """
+        if v is None:
+            return v
+
+        from urllib.parse import urlparse
+
+        # Check if it has a scheme (contains ://)
+        if "://" not in v:
+            # Must be host:port format - validate it has a colon
+            if ":" in v and not v.startswith("/"):
+                return v
+            raise ValueError(_INVALID_ENDPOINT_FORMAT_MSG.format(v))
+
+        # Parse URL with scheme
+        parsed = urlparse(v)
+
+        # Validate scheme (only http/https per OTLP spec, grpc is NOT supported)
+        if parsed.scheme not in ("http", "https"):
+            raise ValueError(_INVALID_ENDPOINT_SCHEME_MSG.format(parsed.scheme))
+
+        # Validate hostname exists
+        if not parsed.hostname:
+            raise ValueError(_MISSING_HOSTNAME_MSG.format(v))
+
+        return v
+
+
+class Config(StrictBaseModel):
+    """Main application configuration.
+
+    Attributes:
+        app_name: Application name
+        secret_key: Flask secret key for sessions
+        db: Database configuration
+        use_www: Redirect non-www to www URLs
+        seo_prefix: URL prefix for SEO routes
+        blog_prefix: URL prefix for blog routes
+        languages: Supported languages configuration
+        domain_to_lang: Domain to language mapping
+        translation_directories: Additional translation directories
+        debug: Enable debug mode
+        testing: Enable testing mode
+        feature_flags: Feature flag configuration
+        telemetry: OpenTelemetry configuration
+    """
+
+    app_name: str = Field(alias="APP_NAME")
+    secret_key: str = Field(alias="SECRET_KEY")
+    db: DBConfig = Field(alias="DB")
+    use_www: bool = Field(default=True, alias="USE_WWW")
+    seo_prefix: str = Field(default="/", alias="SEO_PREFIX")
+    blog_prefix: str = Field(default="/", alias="BLOG_PREFIX")
+    languages: Languages = Field(default_factory=dict, alias="LANGUAGES")
+    domain_to_lang: dict[str, str] = Field(default_factory=dict, alias="DOMAIN_TO_LANG")
+    translation_directories: list[str] = Field(
+        default_factory=list,
+        alias="TRANSLATION_DIRECTORIES",
+    )
+    debug: bool = Field(default=False, alias="DEBUG")
+    testing: bool = Field(default=False, alias="TESTING")
+    feature_flags: t.Optional[dict[str, bool]] = Field(default=None, alias="FEATURE_FLAGS")
+    telemetry: TelemetryConfig = Field(default_factory=TelemetryConfig, alias="TELEMETRY")
+
+    @classmethod
+    def model_validate(
+        cls,
+        obj: t.Any,
+        *,
+        strict: bool | None = None,
+        from_attributes: bool | None = None,
+        context: dict[str, t.Any] | None = None,
+    ) -> "Config":
+        """Validate and construct Config from dictionary.
+
+        Args:
+            obj: Configuration dictionary
+            strict: Enable strict validation
+            from_attributes: Populate from object attributes
+            context: Additional validation context
+
+        Returns:
+            Validated Config instance
+        """
+        db_cfg_type = get_db_module(obj["DB"]["TYPE"]).db_config_type()
+        obj["DB"] = db_cfg_type.model_validate(obj["DB"])
+        return super().model_validate(
+            obj, strict=strict, from_attributes=from_attributes, context=context
+        )
+
+    @classmethod
+    def parse_yaml(cls, path: str) -> "Config":
+        """Parse configuration from YAML file.
+
+        Args:
+            path: Path to YAML configuration file
+
+        Returns:
+            Validated Config instance
+
+        Raises:
+            SystemExit: If config file is not found
+        """
+        try:
+            with open(path, "r") as f:
+                return cls.model_validate(yaml.safe_load(f))
+        except FileNotFoundError:
+            print(f"Config file not found: {path}", file=sys.stderr)
+            raise SystemExit(1)

{platzky-0.4.1 → platzky-1.0.0}/platzky/db/db.py

@@ -96,6 +96,15 @@ class DB(ABC):
     def get_font(self) -> str:
         pass
 
+    @abstractmethod
+    def health_check(self) -> None:
+        """Perform a health check on the database.
+
+        Should raise an exception if the database is not healthy.
+        This should be a lightweight operation suitable for health checks.
+        """
+        pass
+
 
 class DBConfig(BaseModel):
     type: str = Field(alias="TYPE")

{platzky-0.4.1 → platzky-1.0.0}/platzky/db/graph_ql_db.py

@@ -307,3 +307,18 @@ class GraphQL(DB):
             """
         )
         return self.client.execute(plugins_data)["pluginConfigs"]
+
+    def health_check(self) -> None:
+        """Perform a health check on the GraphQL database.
+
+        Raises an exception if the database is not accessible.
+        """
+        # Simple query to check connectivity
+        health_query = gql(
+            """
+            query {
+              __typename
+            }
+            """
+        )
+        self.client.execute(health_query)

{platzky-0.4.1 → platzky-1.0.0}/platzky/db/json_db.py

@@ -116,3 +116,11 @@ class Json(DB):
 
     def get_plugins_data(self):
         return self.data.get("plugins", [])
+
+    def health_check(self) -> None:
+        """Perform a health check on the JSON database.
+
+        Raises an exception if the database is not accessible.
+        """
+        # Try to access site_content to ensure basic structure is valid
+        self._get_site_content()

{platzky-0.4.1 → platzky-1.0.0}/platzky/db/mongodb_db.py

@@ -125,6 +125,14 @@ class MongoDB(DB):
             return site_content.get("font", "")
         return ""
 
+    def health_check(self) -> None:
+        """Perform a health check on the MongoDB database.
+
+        Raises an exception if the database is not accessible.
+        """
+        # Simple ping to check if database is accessible
+        self.client.admin.command("ping")
+
     def _close_connection(self) -> None:
         """Close the MongoDB connection"""
         if self.client:

platzky-1.0.0/platzky/engine.py

@@ -0,0 +1,141 @@
+import os
+from concurrent.futures import ThreadPoolExecutor, TimeoutError
+from typing import Any, Callable, Dict, List, Tuple
+
+from flask import Blueprint, Flask, jsonify, make_response, request, session
+from flask_babel import Babel
+
+from platzky.config import Config
+from platzky.models import CmsModule
+
+
+class Engine(Flask):
+    def __init__(self, config: Config, db, import_name):
+        super().__init__(import_name)
+        self.config.from_mapping(config.model_dump(by_alias=True))
+        self.db = db
+        self.notifiers = []
+        self.login_methods = []
+        self.dynamic_body = ""
+        self.dynamic_head = ""
+        self.health_checks: List[Tuple[str, Callable[[], None]]] = []
+        self.telemetry_instrumented: bool = False
+        directory = os.path.dirname(os.path.realpath(__file__))
+        locale_dir = os.path.join(directory, "locale")
+        config.translation_directories.append(locale_dir)
+        babel_translation_directories = ";".join(config.translation_directories)
+        self.babel = Babel(
+            self,
+            locale_selector=self.get_locale,
+            default_translation_directories=babel_translation_directories,
+        )
+        self._register_default_health_endpoints()
+
+        self.cms_modules: List[CmsModule] = []
+        # TODO add plugins as CMS Module - all plugins should be visible from
+        # admin page at least as configuration
+
+    def notify(self, message: str):
+        for notifier in self.notifiers:
+            notifier(message)
+
+    def add_notifier(self, notifier):
+        self.notifiers.append(notifier)
+
+    def add_cms_module(self, module: CmsModule):
+        """Add a CMS module to the modules list."""
+        self.cms_modules.append(module)
+
+    # TODO login_method should be interface
+    def add_login_method(self, login_method):
+        self.login_methods.append(login_method)
+
+    def add_dynamic_body(self, body: str):
+        self.dynamic_body += body
+
+    def add_dynamic_head(self, body: str):
+        self.dynamic_head += body
+
+    def get_locale(self) -> str:
+        domain = request.headers.get("Host", "localhost")
+        domain_to_lang = self.config.get("DOMAIN_TO_LANG")
+
+        languages = self.config.get("LANGUAGES", {}).keys()
+        backup_lang = session.get(
+            "language",
+            request.accept_languages.best_match(languages, "en"),
+        )
+
+        if domain_to_lang:
+            lang = domain_to_lang.get(domain, backup_lang)
+        else:
+            lang = backup_lang
+
+        session["language"] = lang
+        return lang
+
+    def add_health_check(self, name: str, check_function: Callable[[], None]) -> None:
+        """Register a health check function"""
+        if not callable(check_function):
+            raise TypeError(f"check_function must be callable, got {type(check_function)}")
+        self.health_checks.append((name, check_function))
+
+    def _register_default_health_endpoints(self):
+        """Register default health endpoints"""
+
+        health_bp = Blueprint("health", __name__)
+        HEALTH_CHECK_TIMEOUT = 10  # seconds
+
+        @health_bp.route("/health/liveness")
+        def liveness():
+            """Simple liveness check - is the app running?"""
+            return jsonify({"status": "alive"}), 200
+
+        @health_bp.route("/health/readiness")
+        def readiness():
+            """Readiness check - can the app serve traffic?"""
+            health_status: Dict[str, Any] = {"status": "ready", "checks": {}}
+            status_code = 200
+
+            executor = ThreadPoolExecutor(max_workers=1)
+            try:
+                # Database health check with timeout
+                future = executor.submit(self.db.health_check)
+                try:
+                    future.result(timeout=HEALTH_CHECK_TIMEOUT)
+                    health_status["checks"]["database"] = "ok"
+                except TimeoutError:
+                    health_status["checks"]["database"] = "failed: timeout"
+                    health_status["status"] = "not_ready"
+                    status_code = 503
+                except Exception as e:
+                    health_status["checks"]["database"] = f"failed: {e!s}"
+                    health_status["status"] = "not_ready"
+                    status_code = 503
+
+                # Run application-registered health checks
+                for check_name, check_func in self.health_checks:
+                    future = executor.submit(check_func)
+                    try:
+                        future.result(timeout=HEALTH_CHECK_TIMEOUT)
+                        health_status["checks"][check_name] = "ok"
+                    except TimeoutError:
+                        health_status["checks"][check_name] = "failed: timeout"
+                        health_status["status"] = "not_ready"
+                        status_code = 503
+                    except Exception as e:
+                        health_status["checks"][check_name] = f"failed: {e!s}"
+                        health_status["status"] = "not_ready"
+                        status_code = 503
+            finally:
+                # Shutdown without waiting if any futures are still running
+                executor.shutdown(wait=False)
+
+            return make_response(jsonify(health_status), status_code)
+
+        # Simple /health alias for liveness
+        @health_bp.route("/health")
+        def health():
+            return liveness()
+
+        self.register_blueprint(health_bp)

{platzky-0.4.1 → platzky-1.0.0}/platzky/platzky.py

@@ -17,6 +17,12 @@ from platzky.plugin.plugin_loader import plugify
 from platzky.seo import seo
 from platzky.www_handler import redirect_nonwww_to_www, redirect_www_to_nonwww
 
+_MISSING_OTEL_MSG = (
+    "OpenTelemetry is not installed. Install with: "
+    "poetry add opentelemetry-api opentelemetry-sdk "
+    "opentelemetry-instrumentation-flask opentelemetry-exporter-otlp-proto-grpc"
+)
+
 
 def create_engine(config: Config, db) -> Engine:
     app = Engine(config, db, __name__)
@@ -85,6 +91,20 @@ def create_app_from_config(config: Config) -> Engine:
     db = get_db(config.db)
     engine = create_engine(config, db)
 
+    # Setup telemetry (optional feature)
+    if config.telemetry.enabled:
+        try:
+            from platzky.telemetry import setup_telemetry
+
+            setup_telemetry(engine, config.telemetry)
+        except ImportError as e:
+            raise ImportError(_MISSING_OTEL_MSG) from e
+        except ValueError as e:
+            raise ValueError(
+                f"Telemetry configuration error: {e}. "
+                "Check your telemetry settings in the configuration file."
+            ) from e
+
     admin_blueprint = admin.create_admin_blueprint(
         login_methods=engine.login_methods, cms_modules=engine.cms_modules
     )

platzky-1.0.0/platzky/telemetry.py

@@ -0,0 +1,123 @@
+import atexit
+import socket
+import uuid
+from typing import TYPE_CHECKING, Optional
+
+from platzky.config import TelemetryConfig
+
+if TYPE_CHECKING:
+    from opentelemetry.trace import Tracer
+
+    from platzky.engine import Engine
+
+# Error messages
+_MISSING_EXPORTERS_MSG = (
+    "Telemetry is enabled but no exporters are configured. "
+    "Set endpoint or console_export=True to export traces."
+)
+
+
+def setup_telemetry(app: "Engine", telemetry_config: TelemetryConfig) -> Optional["Tracer"]:
+    """Setup OpenTelemetry tracing for Flask application.
+
+    Configures and initializes OpenTelemetry tracing with OTLP and/or console exporters.
+    Automatically instruments Flask to capture HTTP requests and trace information.
+
+    Args:
+        app: Engine instance (Flask-based application)
+        telemetry_config: Telemetry configuration specifying endpoint and export options
+
+    Returns:
+        OpenTelemetry tracer instance if enabled, None otherwise
+
+    Raises:
+        ImportError: If OpenTelemetry packages are not installed when telemetry is enabled
+        ValueError: If telemetry is enabled but no exporters are configured
+    """
+    if not telemetry_config.enabled:
+        return None
+
+    # Reject telemetry enabled without exporters (creates overhead without benefit)
+    if not telemetry_config.endpoint and not telemetry_config.console_export:
+        raise ValueError(_MISSING_EXPORTERS_MSG)
+
+    # If already instrumented, return tracer without rebuilding provider/exporters
+    if app.telemetry_instrumented:
+        from opentelemetry import trace
+
+        return trace.get_tracer(__name__)
+
+    # Import OpenTelemetry modules (will raise ImportError if not installed)
+    from opentelemetry import trace
+    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+    from opentelemetry.instrumentation.flask import FlaskInstrumentor
+    from opentelemetry.sdk.resources import Resource
+    from opentelemetry.sdk.trace import TracerProvider
+    from opentelemetry.sdk.trace.export import (
+        BatchSpanProcessor,
+        ConsoleSpanExporter,
+        SimpleSpanProcessor,
+    )
+    from opentelemetry.semconv.resource import ResourceAttributes
+
+    # Build resource attributes
+    service_name = app.config.get("APP_NAME", "platzky")
+    resource_attrs: dict[str, str] = {
+        ResourceAttributes.SERVICE_NAME: service_name,
+    }
+
+    # Auto-detect service version from package metadata
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as get_version
+
+    try:
+        resource_attrs[ResourceAttributes.SERVICE_VERSION] = get_version("platzky")
+    except PackageNotFoundError:
+        pass  # Version not available
+
+    if telemetry_config.deployment_environment:
+        resource_attrs[ResourceAttributes.DEPLOYMENT_ENVIRONMENT] = (
+            telemetry_config.deployment_environment
+        )
+
+    # Add instance ID (user-provided or auto-generated)
+    if telemetry_config.service_instance_id:
+        resource_attrs[ResourceAttributes.SERVICE_INSTANCE_ID] = (
+            telemetry_config.service_instance_id
+        )
+    else:
+        # Generate unique instance ID: hostname + short UUID
+        hostname = socket.gethostname()
+        instance_uuid = str(uuid.uuid4())[:8]
+        resource_attrs[ResourceAttributes.SERVICE_INSTANCE_ID] = f"{hostname}-{instance_uuid}"
+
+    resource = Resource.create(resource_attrs)
+    provider = TracerProvider(resource=resource)
+
+    # Configure exporter based on endpoint
+    if telemetry_config.endpoint:
+        exporter = OTLPSpanExporter(
+            endpoint=telemetry_config.endpoint, timeout=telemetry_config.timeout
+        )
+        provider.add_span_processor(BatchSpanProcessor(exporter))
+
+    # Optional console export
+    if telemetry_config.console_export:
+        provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
+
+    trace.set_tracer_provider(provider)
+    FlaskInstrumentor().instrument_app(app)
+    app.telemetry_instrumented = True
+
+    # Optionally flush spans after each request (may impact latency)
+    if telemetry_config.flush_on_request:
+
+        @app.teardown_appcontext
+        def flush_telemetry(_exc: Optional[BaseException] = None) -> None:
+            """Flush pending spans after request completion."""
+            provider.force_flush(timeout_millis=telemetry_config.flush_timeout_ms)
+
+    # Shutdown provider once at process exit
+    atexit.register(provider.shutdown)
+
+    return trace.get_tracer(__name__)

{platzky-0.4.1 → platzky-1.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "platzky"
-version = "0.4.1"
+version = "1.0.0"
 description = "Not only blog engine"
 authors = []
 license = "MIT"
@@ -21,6 +21,28 @@ pydantic = "^2.7.1"
 deprecation = "^2.1.0"
 pygithub = "^2.6.1"
 pymongo = "^4.7.0"
+sphinx = {version = "^8.0.0", optional = true}
+sphinx-rtd-theme = {version = "^3.0.0", optional = true}
+tomli = {version = "^2.0.0", optional = true}
+myst-parser = {version = "^4.0.0", optional = true}
+opentelemetry-api = {version = "^1.27.0", optional = true}
+opentelemetry-sdk = {version = "^1.27.0", optional = true}
+opentelemetry-instrumentation-flask = {version = "^0.48b0", optional = true}
+opentelemetry-exporter-otlp-proto-grpc = {version = "^1.27.0", optional = true}
+
+[tool.poetry.extras]
+docs = [
+    "sphinx",
+    "sphinx-rtd-theme",
+    "myst-parser",
+    "tomli"
+]
+telemetry = [
+    "opentelemetry-api",
+    "opentelemetry-sdk",
+    "opentelemetry-instrumentation-flask",
+    "opentelemetry-exporter-otlp-proto-grpc"
+]
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.2.1"
@@ -31,8 +53,12 @@ black = "^24.8.0"
 ruff = "^0.4.4"
 pyright = "^1.1.364"
 beautifulsoup4 = "^4.12.3"
-python-semantic-release = "^9.0.0"
-
+python-semantic-release = "^9.8.0"
+interrogate = "^1.7.0"
+opentelemetry-api = "^1.27.0"
+opentelemetry-sdk = "^1.27.0"
+opentelemetry-instrumentation-flask = "^0.48b0"
+opentelemetry-exporter-otlp-proto-grpc = "^1.27.0"
 
 [build-system]
 requires = ["poetry-core"]
@@ -42,18 +68,19 @@ build-backend = "poetry.core.masonry.api"
 omit = [
     "tests/*",
     "*/__init__.py"
-    ]
+]
 
 [tool.coverage.report]
 exclude_lines = [
     "@abstractmethod",
     "@abc.abstractmethod"
-    ]
+]
+fail_under = 70
+show_missing = true
 
 [tool.pyright]
 pythonVersion = "3.10"
 pythonPlatform = "All"
-
 typeCheckingMode = "strict"
 reportMissingImports = true
 reportMissingTypeStubs = false
@@ -109,3 +136,18 @@ prerelease = false
 [tool.semantic_release.publish]
 dist_glob_patterns = ["dist/*"]
 upload_to_vcs_release = true
+
+[tool.semantic_release.remote]
+type = "github"
+
+[tool.semantic_release.remote.token]
+env = "GH_TOKEN"
+
+[tool.interrogate]
+fail-under = 20
+ignore-init-method = true
+ignore-init-module = true
+ignore-magic = true
+ignore-private = true
+ignore-semiprivate = false
+exclude = ["tests", "docs"]

platzky-0.4.1/platzky/config.py

@@ -1,69 +0,0 @@
-import sys
-import typing as t
-
-import yaml
-from pydantic import BaseModel, ConfigDict, Field
-
-from .db.db import DBConfig
-from .db.db_loader import get_db_module
-
-
-class StrictBaseModel(BaseModel):
-    model_config = ConfigDict(frozen=True)
-
-
-class LanguageConfig(StrictBaseModel):
-    name: str = Field(alias="name")
-    flag: str = Field(alias="flag")
-    country: str = Field(alias="country")
-    domain: t.Optional[str] = Field(default=None, alias="domain")
-
-
-Languages = dict[str, LanguageConfig]
-LanguagesMapping = t.Mapping[str, t.Mapping[str, str]]
-
-
-def languages_dict(languages: Languages) -> LanguagesMapping:
-    return {name: lang.model_dump() for name, lang in languages.items()}
-
-
-class Config(StrictBaseModel):
-    app_name: str = Field(alias="APP_NAME")
-    secret_key: str = Field(alias="SECRET_KEY")
-    db: DBConfig = Field(alias="DB")
-    use_www: bool = Field(default=True, alias="USE_WWW")
-    seo_prefix: str = Field(default="/", alias="SEO_PREFIX")
-    blog_prefix: str = Field(default="/", alias="BLOG_PREFIX")
-    languages: Languages = Field(default_factory=dict, alias="LANGUAGES")
-    domain_to_lang: dict[str, str] = Field(default_factory=dict, alias="DOMAIN_TO_LANG")
-    translation_directories: list[str] = Field(
-        default_factory=list,
-        alias="TRANSLATION_DIRECTORIES",
-    )
-    debug: bool = Field(default=False, alias="DEBUG")
-    testing: bool = Field(default=False, alias="TESTING")
-    feature_flags: t.Optional[dict[str, bool]] = Field(default_factory=dict, alias="FEATURE_FLAGS")
-
-    @classmethod
-    def model_validate(
-        cls,
-        obj: t.Any,
-        *,
-        strict: bool | None = None,
-        from_attributes: bool | None = None,
-        context: dict[str, t.Any] | None = None,
-    ) -> "Config":
-        db_cfg_type = get_db_module(obj["DB"]["TYPE"]).db_config_type()
-        obj["DB"] = db_cfg_type.model_validate(obj["DB"])
-        return super().model_validate(
-            obj, strict=strict, from_attributes=from_attributes, context=context
-        )
-
-    @classmethod
-    def parse_yaml(cls, path: str) -> "Config":
-        try:
-            with open(path, "r") as f:
-                return cls.model_validate(yaml.safe_load(f))
-        except FileNotFoundError:
-            print(f"Config file not found: {path}", file=sys.stderr)
-            raise SystemExit(1)

platzky-0.4.1/platzky/engine.py

@@ -1,71 +0,0 @@
-import os
-from typing import List
-
-from flask import Flask, request, session
-from flask_babel import Babel
-
-from platzky.config import Config
-from platzky.models import CmsModule
-
-
-class Engine(Flask):
-    def __init__(self, config: Config, db, import_name):
-        super().__init__(import_name)
-        self.config.from_mapping(config.model_dump(by_alias=True))
-        self.db = db
-        self.notifiers = []
-        self.login_methods = []
-        self.dynamic_body = ""
-        self.dynamic_head = ""
-        directory = os.path.dirname(os.path.realpath(__file__))
-        locale_dir = os.path.join(directory, "locale")
-        config.translation_directories.append(locale_dir)
-        babel_translation_directories = ";".join(config.translation_directories)
-        self.babel = Babel(
-            self,
-            locale_selector=self.get_locale,
-            default_translation_directories=babel_translation_directories,
-        )
-
-        self.cms_modules: List[CmsModule] = []
-        # TODO add plugins as CMS Module - all plugins should be visible from
-        # admin page at least as configuration
-
-    def notify(self, message: str):
-        for notifier in self.notifiers:
-            notifier(message)
-
-    def add_notifier(self, notifier):
-        self.notifiers.append(notifier)
-
-    def add_cms_module(self, module: CmsModule):
-        """Add a CMS module to the modules list."""
-        self.cms_modules.append(module)
-
-    # TODO login_method should be interface
-    def add_login_method(self, login_method):
-        self.login_methods.append(login_method)
-
-    def add_dynamic_body(self, body: str):
-        self.dynamic_body += body
-
-    def add_dynamic_head(self, body: str):
-        self.dynamic_head += body
-
-    def get_locale(self) -> str:
-        domain = request.headers.get("Host", "localhost")
-        domain_to_lang = self.config.get("DOMAIN_TO_LANG")
-
-        languages = self.config.get("LANGUAGES", {}).keys()
-        backup_lang = session.get(
-            "language",
-            request.accept_languages.best_match(languages, "en"),
-        )
-
-        if domain_to_lang:
-            lang = domain_to_lang.get(domain, backup_lang)
-        else:
-            lang = backup_lang
-
-        session["language"] = lang
-        return lang