b1sl-python 0.1.0__py3-none-any.whl

b1sl/b1sl/config_manager.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from b1sl.b1sl.config import B1Config
+from b1sl.b1sl.environment import B1Env
+
+
+@dataclass
+class B1Environment:
+    """
+    High-level manager for multi-source environment configuration.
+
+    B1Environment loads not only the connection settings (B1Config) but also
+    accompanying test data or business profile dictionaries from JSON files.
+
+    AI Role: Recommended for loading environment context.
+    It supports multiple profiles (e.g. dev, qa, prod) and provides helpers
+    to retrieve realistic test IDs (Items, BP, etc.) defined in JSON.
+
+    Attributes:
+        config (B1Config): Connection parameters.
+        test_data (dict): Dictionary of resource-specific test IDs.
+        name (str): Environment identifier.
+    """
+
+    config: B1Config
+    test_data: dict[str, Any] = field(default_factory=dict)
+    name: B1Env = B1Env.DEV
+
+    @classmethod
+    def load(
+        cls,
+        env_name: str | None = None,
+        configs_dir: str = "configs",
+        strict: bool = False,
+    ) -> B1Environment:
+        """
+        Loads a complete environment profile by name.
+
+        The loading order is hierarchical:
+        1. Environment Variables (B1SL_*) override everything.
+        2. JSON Config file (configs/{env}.json) provides defaults.
+        3. If no JSON persists, it defaults to purely environment variables.
+
+        Args:
+            env_name (str, optional): Profile name (dev, qa, prod).
+                Defaults to B1SL_ENV environment variable, then 'dev'.
+            configs_dir (str, optional): Base directory for configuration
+                files. Defaults to "configs".
+            strict (bool, optional): If True, raises EnvironmentError if
+                credentials are missing from environment. Default False.
+
+        Returns:
+            B1Environment: A fully populated environment object.
+        """
+        name = B1Env(env_name or os.getenv("B1SL_ENV", "dev").lower())
+        config_path = Path(configs_dir) / f"{name.value}.json"
+
+        # Always start with credentials from OS Environment (.env or system vars)
+        # We load in non-strict mode by default to allow loading test_data even without .env
+        config = B1Config.from_env(strict=strict)
+        config.environment = name
+        
+        test_data = {}
+        if config_path.exists():
+            with open(config_path, "r") as f:
+                data = json.load(f)
+                test_data = data.get("test_data", {})
+
+        return cls(config=config, test_data=test_data, name=name)
+
+

b1sl/b1sl/contrib/__init__.py

@@ -0,0 +1,14 @@
+"""
+b1sl.b1sl.contrib
+~~~~~~~~~~~~~~~~~~~~~~~~
+Framework-specific extensions for the b1sl SDK.
+
+The core SDK (b1sl.b1sl) is fully framework-agnostic.
+This ``contrib`` namespace contains optional integrations for specific web
+frameworks. They are NOT imported by the core SDK and carry no extra
+dependencies unless you use them.
+
+Currently available:
+
+    b1sl.b1sl.contrib.django  — Django middleware, app configs, etc.
+"""

b1sl/b1sl/contrib/django/__init__.py

@@ -0,0 +1,13 @@
+"""
+b1sl.b1sl.contrib.django
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Django-specific extensions for the b1sl SDK.
+
+Add to INSTALLED_APPS if you want Django to discover middleware apps::
+
+    INSTALLED_APPS = [
+        ...
+        "b1sl.b1sl.contrib.django",   # replaces old b1sl.middleware
+        ...
+    ]
+"""

b1sl/b1sl/contrib/django/middleware/__init__.py

@@ -0,0 +1,27 @@
+"""
+b1sl.b1sl.contrib.django.middleware
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Django middleware classes for SAP B1 Service Layer integration.
+
+Add to Django's MIDDLEWARE list::
+
+    MIDDLEWARE = [
+        ...
+        "b1sl.b1sl.contrib.django.middleware.odata_decode_middleware.ODataDecodeMiddleware",
+        # "b1sl.b1sl.contrib.django.middleware.odata_transform_url_middleware.ODataTransformURLMiddleware",
+    ]
+"""
+
+from b1sl.b1sl.contrib.django.middleware.base import SapMiddlewareBase
+from b1sl.b1sl.contrib.django.middleware.odata_decode_middleware import (
+    ODataDecodeMiddleware,
+)
+from b1sl.b1sl.contrib.django.middleware.odata_transform_url_middleware import (
+    ODataTransformURLMiddleware,
+)
+
+__all__ = [
+    "SapMiddlewareBase",
+    "ODataDecodeMiddleware",
+    "ODataTransformURLMiddleware",
+]

b1sl/b1sl/contrib/django/middleware/base.py

@@ -0,0 +1,89 @@
+"""
+b1sl.b1sl.contrib.django.middleware.base
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Framework-agnostic base class for all SAP-aware Django middleware.
+Supports both WSGI (__call__) and ASGI (__acall__) deployments.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+
+class SapMiddlewareBase:
+    """
+    Drop-in Django middleware base that works with both:
+      - WSGI: Django calls __call__(request) synchronously.
+      - ASGI: Django calls __call__(scope, receive, send) or uses
+              the middleware with channels / uvicorn via __acall__.
+
+    Subclass and override `process_request` / `process_response`
+    for custom logic.
+    """
+
+    sync_capable = True
+    async_capable = True
+
+    def __init__(self, get_response: Callable) -> None:
+        self.get_response = get_response
+        # Detect if the downstream handler is async
+        import asyncio
+
+        self._is_coroutine = asyncio.iscoroutinefunction(self.get_response)
+
+    # ------------------------------------------------------------------ #
+    # Hooks — override in subclasses                                       #
+    # ------------------------------------------------------------------ #
+
+    def process_request(self, request):
+        """Synchronous pre-processing hook. Return None to continue."""
+
+    def process_response(self, request, response):
+        """Synchronous post-processing hook. Must return response."""
+        return response
+
+    async def async_process_request(self, request):
+        """Async pre-processing hook. Return None to continue."""
+
+    async def async_process_response(self, request, response):
+        """Async post-processing hook. Must return response."""
+        return response
+
+    # ------------------------------------------------------------------ #
+    # WSGI path                                                            #
+    # ------------------------------------------------------------------ #
+
+    def __call__(self, request):
+        if self._is_coroutine:
+            # Do not call this synchronously on an async handler —
+            # Django will always use __acall__ in that case.
+            import asyncio
+
+            return asyncio.get_event_loop().run_until_complete(self.__acall__(request))
+
+        short_circuit = self.process_request(request)
+        if short_circuit is not None:
+            return short_circuit
+
+        response = self.get_response(request)
+
+        return self.process_response(request, response)
+
+    # ------------------------------------------------------------------ #
+    # ASGI path                                                            #
+    # ------------------------------------------------------------------ #
+
+    async def __acall__(self, request):
+        short_circuit = await self.async_process_request(request)
+        if short_circuit is not None:
+            return short_circuit
+
+        if self._is_coroutine:
+            response = await self.get_response(request)
+        else:
+            response = self.get_response(request)
+
+        return await self.async_process_response(request, response)

b1sl/b1sl/contrib/django/middleware/odata_decode_middleware.py

@@ -0,0 +1,20 @@
+"""
+b1sl.b1sl.contrib.django.middleware.odata_decode_middleware
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+URL-decodes percent-encoded OData query strings before Django routing.
+"""
+
+from urllib.parse import unquote
+
+from b1sl.b1sl.contrib.django.middleware.base import SapMiddlewareBase
+
+
+class ODataDecodeMiddleware(SapMiddlewareBase):
+    """URL-decodes percent-encoded OData query strings before Django routing."""
+
+    def process_request(self, request):
+        if qs := request.META.get("QUERY_STRING"):
+            request.META["QUERY_STRING"] = unquote(qs)
+
+    async def async_process_request(self, request):
+        self.process_request(request)  # pure string op, no I/O

b1sl/b1sl/contrib/django/middleware/odata_transform_url_middleware.py

@@ -0,0 +1,20 @@
+"""
+b1sl.b1sl.contrib.django.middleware.odata_transform_url_middleware
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Transforms OData-style URLs (replacing parentheses) before Django routing.
+"""
+
+from b1sl.b1sl.contrib.django.middleware.base import SapMiddlewareBase
+
+
+class ODataTransformURLMiddleware(SapMiddlewareBase):
+    """Transforms OData-style URLs (replacing parenthesis) before Django routing."""
+
+    def process_request(self, request):
+        path = request.path
+        if "(" in path and ")" in path:
+            # Replace '(' and ')' with '/'
+            request.path = path.replace("(", "/").replace(")", "")
+
+    async def async_process_request(self, request):
+        self.process_request(request)  # pure string op, no I/O