b1sl-python 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

b1sl/b1sl/adapter_protocol.py

@@ -12,17 +12,17 @@ class RestAdapterProtocol(Protocol):
     """
 
     def get(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...
 
     def post(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...
 
     def patch(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...
 
     def delete(
-        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None, headers: dict | None = None
     ) -> Result: ...

b1sl/b1sl/async_client.py

@@ -8,6 +8,7 @@ from b1sl.b1sl.base_adapter import ObservabilityConfig
 from b1sl.b1sl.config import B1Config
 
 if TYPE_CHECKING:
+    from b1sl.b1sl.batch.client import BatchClient
     from b1sl.b1sl.models._generated.entities.businesspartners import (
         Activity,
         BusinessPartner,
@@ -98,6 +99,30 @@ class AsyncB1Client:
         """
         return self._adapter.dry_run(enabled)
 
+    def with_schema(self, name: str):
+        """
+        Context manager to temporarily set the B1S-Schema header
+        **for the current asyncio.Task only** (task-safe via ContextVar).
+        
+        Usage::
+        
+            async with AsyncB1Client(config) as b1:
+                async with b1.with_schema("demo.schema"):
+                    await b1.items.get("A0001")
+        """
+        return self._adapter.with_schema(name)
+
+    def batch(self) -> BatchClient:
+        """
+        Returns a context manager that groups multiple resource operations
+        into a single OData $batch HTTP request.
+
+        Use this for high-concurrency scenarios (bulk GETs) or transactional
+        integrity (atomic ChangeSets). See :class:`BatchClient` for details.
+        """
+        from b1sl.b1sl.batch.client import BatchClient
+        return BatchClient(self)
+
     async def connect(self) -> None:
         """
         Initializes the underlying HTTP client and logs in.

b1sl/b1sl/async_rest_adapter.py

@@ -215,6 +215,7 @@ class AsyncRestAdapter(BaseRestAdapter):
         endpoint: str,
         ep_params=None,
         data=None,
+        headers: dict | None = None,
         _is_login: bool = False,
         _retry_once=True,
     ) -> Result:
@@ -240,7 +241,9 @@ class AsyncRestAdapter(BaseRestAdapter):
 
         try:
             # ── ETag: inject If-None-Match (GET) or If-Match (PATCH/DELETE/POST) ──
-            headers = self._build_headers(http_method, endpoint_path)
+            req_headers = self._build_headers(http_method, endpoint_path)
+            if headers:
+                req_headers.update(headers)
 
             if self._dry_run_active and http_method in {"POST", "PATCH", "DELETE"} and not _is_login:
                 self._logger.info(f"[{req_id}] [DRY RUN] Intercepting {http_method} {full_url}")
@@ -250,7 +253,7 @@ class AsyncRestAdapter(BaseRestAdapter):
             else:
                 response = await self._client.request(
                     method=http_method, url=full_url, params=ep_params, json=data,
-                    headers=headers,
+                    headers=req_headers,
                 )
 
             if response.status_code == 401 and _retry_once and not _is_login:
@@ -259,7 +262,7 @@ class AsyncRestAdapter(BaseRestAdapter):
                 # Recursive call will handle its own finally block,
                 # but we need to return here to avoid double-logging/hooking.
                 return await self._do(
-                    http_method, endpoint, ep_params, data, _is_login, _retry_once=False
+                    http_method, endpoint, ep_params, data, headers, _is_login, _retry_once=False
                 )
 
             response.raise_for_status()
@@ -308,7 +311,7 @@ class AsyncRestAdapter(BaseRestAdapter):
                     status_code=status_code,
                     duration_ms=duration_ms,
                     payload=log_data if http_method in {"POST", "PATCH"} else None,
-                    if_match=headers.get("If-Match"),
+                    if_match=req_headers.get("If-Match"),
                     extra=context_extras,
                     exc=exc_captured,
                 )
@@ -347,18 +350,33 @@ class AsyncRestAdapter(BaseRestAdapter):
                 f"HTTP Error {response.status_code if response else 'Unknown'}"
             )
 
-    async def get(self, endpoint, ep_params=None, data=None):
+    async def get(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous GET request."""
-        return await self._do("GET", endpoint, ep_params, data)
+        return await self._do("GET", endpoint, ep_params, data, headers=headers)
 
-    async def post(self, endpoint, ep_params=None, data=None):
+    async def post(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous POST request."""
-        return await self._do("POST", endpoint, ep_params, data)
+        return await self._do("POST", endpoint, ep_params, data, headers=headers)
 
-    async def patch(self, endpoint, ep_params=None, data=None):
+    async def patch(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous PATCH request."""
-        return await self._do("PATCH", endpoint, ep_params, data)
+        return await self._do("PATCH", endpoint, ep_params, data, headers=headers)
 
-    async def delete(self, endpoint, ep_params=None, data=None):
+    async def delete(self, endpoint, ep_params=None, data=None, headers=None):
         """Execute an asynchronous DELETE request."""
-        return await self._do("DELETE", endpoint, ep_params, data)
+        return await self._do("DELETE", endpoint, ep_params, data, headers=headers)
+
+    async def post_batch(self, body: str, headers: dict) -> httpx.Response:
+        """
+        Special method to send raw multipart content for $batch operations.
+        """
+        await self.ensure_session()
+        if not self._client:
+             raise B1Exception("AsyncRestAdapter not initialized.")
+        
+        url = f"{self.raw_base_url}/$batch"
+        # Combine with session headers if necessary,
+        # although httpx already handles them via cookies.
+        response = await self._client.post(url, content=body, headers=headers)
+        response.raise_for_status()
+        return response

b1sl/b1sl/base_adapter.py

@@ -185,12 +185,20 @@ class BaseRestAdapter:
         self._dry_run_var: ContextVar[bool] = ContextVar(
             f"dry_run_{id(self)}", default=config.dry_run
         )
+        self._b1s_schema_var: ContextVar[str | None] = ContextVar(
+            f"b1s_schema_{id(self)}", default=config.b1s_schema
+        )
 
     @property
     def _dry_run_active(self) -> bool:
         """Returns the current effective dry_run state for this task/thread."""
         return self._dry_run_var.get()
 
+    @property
+    def _schema_active(self) -> str | None:
+        """Returns the current effective schema state for this task/thread."""
+        return self._b1s_schema_var.get()
+
     @contextmanager
     def dry_run(self, enabled: bool = True):
         """
@@ -220,6 +228,28 @@ class BaseRestAdapter:
         finally:
             self._dry_run_var.reset(token)
 
+    @contextmanager
+    def with_schema(self, schema: str | None):
+        """
+        Context manager to temporarily override the B1S-Schema header
+        **for the current asyncio task / thread only**.
+
+        Usage::
+
+            # Use a specific schema for this block
+            with client.with_schema("demo.schema"):
+                await client.items.get("A0001")
+
+        Note:
+            Use ``with``, not ``async with`` — the context manager is
+            synchronous even in async code, which is correct and idiomatic.
+        """
+        token = self._b1s_schema_var.set(schema)
+        try:
+            yield
+        finally:
+            self._b1s_schema_var.reset(token)
+
     @classmethod
     def from_config(
         cls,
@@ -328,6 +358,10 @@ class BaseRestAdapter:
             # POST covers OData Actions (e.g. /BusinessPartners('C20000')/Cancel)
             headers["If-Match"] = cached_etag
 
+        active_schema = self._schema_active
+        if active_schema:
+            headers["B1S-Schema"] = active_schema
+
         if extra_headers:
             headers.update(extra_headers)
         return headers

b1sl/b1sl/batch/__init__.py

@@ -0,0 +1,6 @@
+"""OData $batch support for the b1sl SDK."""
+
+from .client import BatchClient
+from .results import BatchResult, BatchResults
+
+__all__ = ["BatchClient", "BatchResult", "BatchResults"]

b1sl/b1sl/batch/_recording_adapter.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Type
+
+from b1sl.b1sl.models.result import Result
+
+if TYPE_CHECKING:
+    from b1sl.b1sl.models.base import B1Model
+
+    from .client import BatchClient
+
+@dataclass
+class PendingRequest:
+    """Represents an enqueued request within a batch."""
+    method: str
+    endpoint: str
+    data: dict | None = None
+    ep_params: dict | None = None
+    model_type: Type[B1Model] | None = None
+    changeset_id: str | None = None
+    content_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+
+class _RecordingAdapter:
+    """
+    Internal adapter that captures requests instead of executing them.
+    Complies with the RestAdapterProtocol asynchronously.
+    """
+    def __init__(self, batch_client: BatchClient):
+        self._batch = batch_client
+        self._current_model: Type[B1Model] | None = None
+
+    def _record(self, method: str, endpoint: str, ep_params: dict | None = None, data: dict | None = None):
+        """Captures the request and adds it to the client's queue."""
+        if method == "GET" and self._batch.active_changeset_id:
+            raise ValueError("OData Batch Error: GET operations are not allowed within a ChangeSet.")
+
+        req = PendingRequest(
+            method=method,
+            endpoint=endpoint,
+            ep_params=ep_params,
+            data=data,
+            model_type=self._current_model,
+            changeset_id=self._batch.active_changeset_id
+        )
+        self._batch._pending.append(req)
+        
+        # Return a simulated Result so Pydantic doesn't crash
+        return Result(status_code=202, data={})
+
+    # Asynchronous implementation for AsyncGenericResource
+    async def get(self, endpoint, ep_params=None, data=None):
+        return self._record("GET", endpoint, ep_params, data)
+
+    async def post(self, endpoint, ep_params=None, data=None):
+        return self._record("POST", endpoint, ep_params, data)
+
+    async def patch(self, endpoint, ep_params=None, data=None):
+        return self._record("PATCH", endpoint, ep_params, data)
+
+    async def delete(self, endpoint, ep_params=None, data=None):
+        return self._record("DELETE", endpoint, ep_params, data)
+
+    # Synchronous implementation for GenericResource (compatibility)
+    def get_sync(self, endpoint, ep_params=None, data=None):
+        return self._record("GET", endpoint, ep_params, data)

b1sl/b1sl/batch/changeset.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .client import BatchClient
+
+class ChangeSetContext:
+    """
+    Manages the lifecycle of a ChangeSet in OData.
+    Ensures that operations are atomic and prohibits GETs.
+    """
+    def __init__(self, batch_client: BatchClient):
+        self._batch = batch_client
+        self._changeset_id = f"changeset_{uuid.uuid4()}"
+
+    def __enter__(self) -> BatchClient:
+        self._batch.active_changeset_id = self._changeset_id
+        return self._batch
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._batch.active_changeset_id = None
+
+    async def __aenter__(self) -> BatchClient:
+        return self.__enter__()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        return self.__exit__(exc_type, exc_val, exc_tb)

b1sl/b1sl/batch/client.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import copy
+import functools
+import inspect
+import re
+import uuid
+from typing import TYPE_CHECKING, Any, Callable
+
+from ._recording_adapter import PendingRequest, _RecordingAdapter
+from .changeset import ChangeSetContext
+from .parser import BatchParser
+from .results import BatchResults
+from .serializer import BatchSerializer
+
+if TYPE_CHECKING:
+    from b1sl.b1sl import AsyncB1Client, B1Client
+
+class ResourceProxy:
+    """Recursive proxy for capturing batch requests."""
+    def __init__(self, target: Any, adapter: _RecordingAdapter, client: BatchClient):
+        self._target = target
+        self._adapter = adapter
+        self._client = client
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("_"):
+            return getattr(self._target, name)
+        attr = getattr(self._target, name)
+        if inspect.iscoroutinefunction(attr):
+            return self._wrap_async(attr)
+        if callable(attr):
+            return self._wrap_callable(attr)
+        return attr
+
+    def _wrap_async(self, method: Callable) -> Callable:
+        @functools.wraps(method)
+        async def wrapper(*args, **kwargs):
+            model = getattr(self._target, "model", None)
+            if model is None and hasattr(self._target, "_resource"):
+                model = getattr(self._target._resource, "model", None)
+            self._adapter._current_model = model
+            try:
+                await method(*args, **kwargs)
+            except (AttributeError, TypeError):
+                # Suppress infrastructure errors from the proxy mechanism;
+                # business-logic exceptions (e.g. ValueError for GET-in-ChangeSet)
+                # are intentionally allowed to propagate.
+                pass
+            return None
+        return wrapper
+
+    def _wrap_callable(self, method: Callable) -> Callable:
+        @functools.wraps(method)
+        def wrapper(*args, **kwargs):
+            result = method(*args, **kwargs)
+            if hasattr(result, "__dict__") or hasattr(result, "_adapter"):
+                if hasattr(result, "_adapter"):
+                    setattr(result, "_adapter", self._adapter)
+                if hasattr(result, "_resource") and hasattr(result._resource, "_adapter"):
+                    setattr(result._resource, "_adapter", self._adapter)
+                return ResourceProxy(result, self._adapter, self._client)
+            return result
+        return wrapper
+
+class BatchClient:
+    """OData Batch Orchestrator."""
+    def __init__(self, b1_session: AsyncB1Client | B1Client):
+        self._b1 = b1_session
+        self._pending: list[PendingRequest] = []
+        self._adapter = _RecordingAdapter(self)
+        self.active_changeset_id: str | None = None
+        self._batch_boundary = f"batch_{uuid.uuid4()}"
+
+    def __getattr__(self, name: str) -> Any:
+        real_resource = getattr(self._b1, name)
+        new_resource = copy.copy(real_resource)
+        if hasattr(new_resource, "_adapter"):
+            new_resource._adapter = self._adapter
+        return ResourceProxy(new_resource, self._adapter, self)
+
+    def changeset(self) -> ChangeSetContext:
+        return ChangeSetContext(self)
+
+    def _extract_response_boundary(self, response_content_type: str) -> str | None:
+        """Extracts the boundary string from a SAP Content-Type response header."""
+        match = re.search(r"boundary=([^\s;]+)", response_content_type)
+        if match:
+            return match.group(1).strip().replace('"', '')
+        return None
+
+    async def execute(self) -> BatchResults:
+        """Dynamically serializes, sends, and parses the batch."""
+        if not self._pending:
+            return BatchResults([])
+
+        serializer = BatchSerializer(self._pending, self._batch_boundary)
+        body = serializer.serialize()
+
+        real_adapter = getattr(self._b1, "_adapter") 
+        headers = {"Content-Type": f"multipart/mixed; boundary={self._batch_boundary}"}
+        
+        response = await real_adapter.post_batch(body, headers)
+        
+        # IMPORTANT: Use the boundary that SAP returns in its response
+        resp_ct = response.headers.get("Content-Type", "")
+        resp_boundary = self._extract_response_boundary(resp_ct)
+
+        # Fallback: use the request boundary if SAP omits it in the response
+        boundary_to_use = resp_boundary or self._batch_boundary
+
+        parser = BatchParser(response.text, boundary_to_use)
+        expected_models = [req.model_type for req in self._pending]
+        raw_results = parser.parse(expected_models)
+        
+        return BatchResults(raw_results)
+
+    async def __aenter__(self) -> BatchClient:
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        # Reset internal state to prevent accidental reuse of a consumed BatchClient.
+        self._pending.clear()
+        self.active_changeset_id = None

b1sl/b1sl/batch/parser.py

@@ -0,0 +1,120 @@
+import json
+import re
+from typing import Type
+
+from .results import BatchResult
+
+
+class BatchParser:
+    """Parses multipart/mixed responses from SAP SL."""
+
+    def __init__(self, content: str, boundary: str):
+        self.content = content
+        self.boundary = boundary
+
+    def parse(self, expected_models: list[Type] | None = None) -> list[BatchResult]:
+        results = []
+        parts = self._split_parts(self.content, self.boundary)
+
+        # Original request index tracker
+        request_idx = 0
+
+        for part in parts:
+            if "Content-Type: multipart/mixed" in part:
+                # It's a ChangeSet. SAP returns its responses in a nested block.
+                sub_boundary = self._extract_boundary(part)
+                if sub_boundary:
+                    sub_parts = self._split_parts(part, sub_boundary)
+                    for sub_part in sub_parts:
+                        model = expected_models[request_idx] if expected_models and request_idx < len(expected_models) else None
+                        res = self._parse_single_http_response(sub_part, model, index=request_idx)
+                        results.append(res)
+                        request_idx += 1
+                continue
+
+            # Simple response outside of changeset
+            model = expected_models[request_idx] if expected_models and request_idx < len(expected_models) else None
+            res = self._parse_single_http_response(part, model, index=request_idx)
+            results.append(res)
+            request_idx += 1
+
+        return results
+
+    def _split_parts(self, content: str, boundary: str) -> list[str]:
+        """Divides the content into real parts by scanning delimiters."""
+        parts = []
+        current_part: list[str] = []
+        token = f"--{boundary}"
+        end_token = f"--{boundary}--"
+        
+        in_part = False
+        lines = content.replace("\r\n", "\n").split("\n")
+        
+        for line in lines:
+            trimmed = line.strip()
+            if trimmed == token:
+                if in_part and current_part:
+                    parts.append("\n".join(current_part))
+                current_part = []
+                in_part = True
+                continue
+            
+            if trimmed == end_token:
+                if in_part and current_part:
+                    parts.append("\n".join(current_part))
+                current_part = []
+                in_part = False
+                continue
+            
+            if in_part:
+                current_part.append(line)
+        
+        if in_part and current_part:
+            parts.append("\n".join(current_part))
+            
+        return parts
+
+    def _extract_boundary(self, content: str) -> str:
+        match = re.search(r"boundary=([^\s;]+)", content)
+        if match:
+             return match.group(1).strip().replace('"', '')
+        return ""
+
+    def _parse_single_http_response(
+        self, raw_http: str, model_type: Type | None = None, index: int = 0
+    ) -> BatchResult:
+        """Parses an individual HTTP response part."""
+        start_idx = raw_http.find("HTTP/1.1")
+        if start_idx == -1:
+            return BatchResult(status=500, error="Invalid part format")
+            
+        message = raw_http[start_idx:]
+        
+        status_match = re.search(r"HTTP/1\.1\s+(\d+)", message)
+        status = int(status_match.group(1)) if status_match else 500
+        
+        body = None
+        msg_normalized = message.replace("\r\n", "\n")
+        header_body_split = re.split(r"\n\s*\n", msg_normalized, 1)
+        
+        if len(header_body_split) > 1:
+            json_str = header_body_split[1].strip()
+            if json_str:
+                try:
+                    body = json.loads(json_str)
+                except Exception:
+                    body = json_str
+
+        error_msg = None
+        if status >= 400:
+            if isinstance(body, dict) and "error" in body:
+                err = body["error"]
+                if isinstance(err, dict):
+                    msg = err.get("message")
+                    error_msg = msg.get("value") if isinstance(msg, dict) else str(msg)
+                else:
+                    error_msg = str(err)
+            if not error_msg:
+                error_msg = str(body)
+
+        return BatchResult(status=status, data=body, error=error_msg, model_type=model_type, index=index)

b1sl/b1sl/batch/results.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Type
+
+if TYPE_CHECKING:
+    from b1sl.b1sl.models.base import B1Model
+
+@dataclass
+class BatchResult:
+    """Individual result of an operation within a batch."""
+    status: int
+    data: Any = None
+    error: str | None = None
+    model_type: Type[B1Model] | None = None
+    index: int = 0  # Original position in the batch
+
+    @property
+    def ok(self) -> bool:
+        return 200 <= self.status < 300
+
+    @property
+    def entity(self) -> Any:
+        """Returns the parsed data as a Pydantic model if available."""
+        if self.ok and self.model_type and isinstance(self.data, (dict, list)):
+            if isinstance(self.data, list):
+                return [self.model_type.model_validate(item) for item in self.data]
+            # Special case: SAP sometimes returns the object in a 'value' node or directly
+            val = self.data.get("value", self.data) if isinstance(self.data, dict) else self.data
+            if isinstance(val, list):
+                return [self.model_type.model_validate(item) for item in val]
+            return self.model_type.model_validate(val)
+        return self.data
+
+class BatchResults:
+    """Intelligent container for the results of a complete batch."""
+    def __init__(self, results: list[BatchResult]):
+        self.results = results
+
+    @property
+    def all_ok(self) -> bool:
+        return all(r.ok for r in self.results)
+
+    @property
+    def failed(self) -> list[BatchResult]:
+        """Returns only the failed operations, preserving their original index."""
+        return [r for r in self.results if not r.ok]
+
+    def __len__(self):
+        return len(self.results)
+
+    def __getitem__(self, idx: int) -> BatchResult:
+        return self.results[idx]
+
+    def __iter__(self):
+        return iter(self.results)