b1sl-python 0.1.0__py3-none-any.whl

b1sl/__init__.py

@@ -0,0 +1,5 @@
+"""
+SAP Clients Package
+"""
+
+__version__ = "0.1.0"

b1sl/b1sl/__init__.py

@@ -0,0 +1,56 @@
+"""
+b1sl.b1sl — SDK for SAP B1 Service Layer (OData).
+"""
+
+import logging
+import warnings
+
+try:
+    from pydantic import ArbitraryTypeWarning
+
+    warnings.filterwarnings("ignore", category=ArbitraryTypeWarning, module=r"b1sl\..*")
+except ImportError:
+    warnings.filterwarnings("ignore", module=r"b1sl\..*|pydantic\..*")
+
+# Standard library pattern: prevent "No handlers could be found"
+logging.getLogger("b1sl").addHandler(logging.NullHandler())
+
+from b1sl.b1sl.async_client import AsyncB1Client
+from b1sl.b1sl.async_rest_adapter import AsyncRestAdapter
+from b1sl.b1sl.base_adapter import HookContext, ObservabilityConfig
+from b1sl.b1sl.client import B1Client
+from b1sl.b1sl.config import B1Config
+from b1sl.b1sl.config_manager import B1Environment
+from b1sl.b1sl.environment import B1Env
+from b1sl.b1sl.exceptions.exceptions import SAPConcurrencyError
+from b1sl.b1sl.resources.async_base import AsyncGenericResource
+from b1sl.b1sl.resources.base import GenericResource, ODataQuery
+from b1sl.b1sl.rest_adapter import RestAdapter
+
+try:
+    from b1sl.b1sl import entities
+except ImportError:
+    entities = None  # Before code generation
+
+try:
+    from b1sl.b1sl import fields
+except ImportError:
+    fields = None
+
+__all__ = [
+    "B1Client",
+    "AsyncB1Client",
+    "B1Config",
+    "B1Env",
+    "B1Environment",
+    "RestAdapter",
+    "AsyncRestAdapter",
+    "GenericResource",
+    "AsyncGenericResource",
+    "entities",
+    "fields",
+    "ODataQuery",
+    "HookContext",
+    "ObservabilityConfig",
+    "SAPConcurrencyError",
+]

b1sl/b1sl/_types.py

@@ -0,0 +1,28 @@
+"""
+b1sl.b1sl._types
+~~~~~~~~~~~~~~~~~~~~~~
+Shared generic type variables for the SDK.
+
+Import ``T`` from here instead of re-declaring it per-module so that
+static analysis tools (mypy, pyright) resolve the same TypeVar object
+across resource classes and the public API.
+
+Usage::
+
+    from b1sl.b1sl._types import T
+
+    def get(self, code: str, *, model: Type[T] | None = None) -> MyModel | T:
+        ...
+"""
+
+from __future__ import annotations
+
+from typing import TypeVar
+
+from pydantic import BaseModel
+
+# T represents *any* Pydantic model a downstream developer injects.
+# Bound to BaseModel so IDEs know every T has .model_validate(), .model_dump(), etc.
+T = TypeVar("T", bound=BaseModel)
+
+__all__ = ["T"]

b1sl/b1sl/adapter.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import logging
+
+from b1sl.b1sl.config import B1Config
+from b1sl.b1sl.rest_adapter import RestAdapter
+
+# ── Legacy Django-only shared adapter ──────────────────────────────────────
+# Prefer B1Client (via web/services/b1sl.py) for all new code.
+# This module exists only for the legacy *_endpoint.py classes that have not
+# yet been migrated to constructor-injected RestAdapter.
+#
+# NOTE: RestAdapter is no longer a Singleton. This module-level global IS the
+# single shared instance for legacy endpoints. Do not instantiate RestAdapter
+# directly in endpoint classes.
+
+_logger = logging.getLogger(__name__)
+_rest_adapter: RestAdapter | None = None
+
+
+def get_rest_adapter() -> RestAdapter:
+    """Return (or lazily create) the shared Django adapter instance."""
+    global _rest_adapter
+    if _rest_adapter is None:
+        _rest_adapter = RestAdapter.from_config(B1Config.from_django_settings())
+    return _rest_adapter
+
+
+# Eager init — fails silently if Django settings are not ready yet.
+# Legacy endpoints that import `rest_adapter` directly will get None until
+# settings are fully loaded; get_rest_adapter() will correct this on first call.
+try:
+    rest_adapter = get_rest_adapter()
+except Exception as _e:
+    _logger.warning(
+        "b1sl.b1sl.adapter: could not eagerly initialise rest_adapter "
+        f"({_e!r}). Legacy endpoints will fail until Django settings are ready. "
+        "Call get_rest_adapter() explicitly after settings are loaded."
+    )
+    rest_adapter = None

b1sl/b1sl/adapter_protocol.py

@@ -0,0 +1,28 @@
+from typing import Protocol
+
+from b1sl.b1sl.models.result import Result
+
+
+class RestAdapterProtocol(Protocol):
+    """
+    Interface protocol for components that execute HTTP requests
+    against SAP B1 Service Layer and return Result objects.
+
+    Implemented statically by both the real RestAdapter and its Fakes.
+    """
+
+    def get(
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+    ) -> Result: ...
+
+    def post(
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+    ) -> Result: ...
+
+    def patch(
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+    ) -> Result: ...
+
+    def delete(
+        self, endpoint: str, ep_params: dict | None = None, data: dict | None = None
+    ) -> Result: ...

b1sl/b1sl/async_client.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from b1sl.b1sl.async_rest_adapter import AsyncRestAdapter
+from b1sl.b1sl.base_adapter import ObservabilityConfig
+from b1sl.b1sl.config import B1Config
+
+if TYPE_CHECKING:
+    from b1sl.b1sl.models.base import B1Model
+    from b1sl.b1sl.resources.async_base import AsyncGenericResource
+    from b1sl.b1sl.resources.udo import AsyncUDOResource
+    
+    # Models for typing convenience aliases
+    from b1sl.b1sl.models._generated.entities.inventory import Item
+    from b1sl.b1sl.models._generated.entities.businesspartners import BusinessPartner, Activity
+    from b1sl.b1sl.models._generated.entities.general import Document, Payment, User
+    from b1sl.b1sl.models._generated.entities.production import ProductionOrder
+    from b1sl.b1sl.models._generated.entities.finance import JournalEntry
+    from b1sl.b1sl.models._generated.entities.sales import ServiceCall
+
+
+class AsyncB1Client:
+    """
+    Main asynchronous entry point for the SAP B1 Service Layer SDK.
+
+    This client is designed for high-concurrency environments like FastAPI,
+    Temporal, or Sanic. It uses an asynchronous context manager for automated
+    session management and httpx for non-blocking I/O.
+
+    AI Role: Recommended for modern web apps.
+    Use 'async with AsyncB1Client(config) as b1:' to ensure session cleanup.
+
+    Example:
+        async with AsyncB1Client(config) as b1:
+            item = await b1.items.get("A0001")
+    """
+
+    def __init__(
+        self,
+        config: B1Config,
+        logger: logging.Logger | None = None,
+        version: str = "v2",
+        *,
+        observability: ObservabilityConfig | None = None,
+        session_id: str | None = None,
+    ) -> None:
+        """
+        Initializes the AsyncB1Client.
+
+        Args:
+            config (B1Config): Validated configuration object.
+            logger (logging.Logger, optional): Custom logger; defaults
+                to a prefixed 'b1sl.AsyncB1Client' logger.
+            version (str): API version (defaults to 'v2').
+            session_id (str, optional): An existing B1SESSION cookie to reuse.
+        """
+        self._adapter = AsyncRestAdapter(
+            config,
+            logger=logger,
+            version=version,
+            observability=observability,
+            session_id=session_id,
+        )
+        self.version = version
+
+    @property
+    def session_id(self) -> str | None:
+        """
+        Retrieves the current SAP session ID.
+
+        Returns:
+            str: B1SESSION cookie value or None.
+        """
+        return self._adapter.session_id
+
+    async def connect(self) -> None:
+        """
+        Initializes the underlying HTTP client and logs in.
+        Must be called if not using the async context manager.
+        """
+        await self._adapter.connect()
+
+    async def aclose(self) -> None:
+        """
+        Logs out and closes the HTTP connection pool.
+        Must be called to ensure clean shutdown if not using context manager.
+        """
+        await self._adapter.aclose()
+
+    async def __aenter__(self) -> AsyncB1Client:
+        """
+        Entry point for the async context manager.
+        Logins and prepares the session.
+        """
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """
+        Exit point for the async context manager.
+        Ensures logout and connection pool cleanup.
+        """
+        await self.aclose()
+
+    def get_resource(
+        self, model: type["B1Model"], endpoint: str
+    ) -> "AsyncGenericResource":
+        """
+        Instantiates a generic resource accessor for the given SAP entity.
+
+        AI Role: This is the primary, canonical way to map any Pydantic model
+        to an arbitrary Service Layer endpoint concurrently.
+        """
+        from b1sl.b1sl.resources.async_base import AsyncGenericResource
+
+        class DynamicResource(AsyncGenericResource):
+            pass
+
+        DynamicResource.endpoint = endpoint
+        DynamicResource.model = model
+
+        return DynamicResource(self._adapter)
+
+    # --------------------------------------------------------------------------
+    # Thin Aliases for common endpoints (Developer Experience)
+    # --------------------------------------------------------------------------
+
+    @property
+    def items(self) -> "AsyncGenericResource[Item]":
+        """Convenience alias for get_resource(Item, 'Items')."""
+        from b1sl.b1sl.models._generated.entities.inventory import Item
+
+        return self.get_resource(Item, "Items")
+
+    @property
+    def business_partners(self) -> "AsyncGenericResource[BusinessPartner]":
+        """Convenience alias for get_resource(BusinessPartner, 'BusinessPartners')."""
+        from b1sl.b1sl.models._generated.entities.businesspartners import (
+            BusinessPartner,
+        )
+
+        return self.get_resource(BusinessPartner, "BusinessPartners")
+
+    @property
+    def invoices(self) -> "AsyncGenericResource[Document]":
+        """Convenience alias for get_resource(Document, 'Invoices')."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+
+        return self.get_resource(Document, "Invoices")
+
+    @property
+    def quotations(self) -> "AsyncGenericResource[Document]":
+        """Convenience alias for get_resource(Document, 'Quotations')."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+
+        return self.get_resource(Document, "Quotations")
+
+    @property
+    def orders(self) -> "AsyncGenericResource[Document]":
+        """Convenience alias for get_resource(Document, 'Orders')."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+
+        return self.get_resource(Document, "Orders")
+
+    @property
+    def delivery_notes(self) -> "AsyncGenericResource[Document]":
+        """Convenience alias for get_resource(Document, 'DeliveryNotes')."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+
+        return self.get_resource(Document, "DeliveryNotes")
+
+    @property
+    def purchase_orders(self) -> "AsyncGenericResource[Document]":
+        """Convenience alias for get_resource(Document, 'PurchaseOrders')."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+
+        return self.get_resource(Document, "PurchaseOrders")
+
+    @property
+    def purchase_delivery_notes(self) -> "AsyncGenericResource[Document]":
+        """Convenience alias for get_resource(Document, 'PurchaseDeliveryNotes')."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+
+        return self.get_resource(Document, "PurchaseDeliveryNotes")
+
+    @property
+    def purchase_invoices(self) -> "AsyncGenericResource[Document]":
+        """Convenience alias for get_resource(Document, 'PurchaseInvoices')."""
+        from b1sl.b1sl.models._generated.entities.general import Document
+
+        return self.get_resource(Document, "PurchaseInvoices")
+
+    @property
+    def incoming_payments(self) -> "AsyncGenericResource[Payment]":
+        """Convenience alias for get_resource(Payment, 'IncomingPayments')."""
+        from b1sl.b1sl.models._generated.entities.general import Payment
+
+        return self.get_resource(Payment, "IncomingPayments")
+
+    @property
+    def vendor_payments(self) -> "AsyncGenericResource[Payment]":
+        """Convenience alias for get_resource(Payment, 'VendorPayments')."""
+        from b1sl.b1sl.models._generated.entities.general import Payment
+
+        return self.get_resource(Payment, "VendorPayments")
+
+    @property
+    def users(self) -> "AsyncGenericResource[User]":
+        """Convenience alias for get_resource(User, 'Users')."""
+        from b1sl.b1sl.models._generated.entities.general import User
+
+        return self.get_resource(User, "Users")
+
+    # --- Producción & Operaciones ---
+
+    @property
+    def production_orders(self) -> "AsyncGenericResource[ProductionOrder]":
+        """Convenience alias for get_resource(ProductionOrder, 'ProductionOrders')."""
+        from b1sl.b1sl.models._generated.entities.production import ProductionOrder
+
+        return self.get_resource(ProductionOrder, "ProductionOrders")
+
+    # --- Contabilidad & Finanzas ---
+
+    @property
+    def journal_entries(self) -> "AsyncGenericResource[JournalEntry]":
+        """Convenience alias for get_resource(JournalEntry, 'JournalEntries')."""
+        from b1sl.b1sl.models._generated.entities.finance import JournalEntry
+
+        return self.get_resource(JournalEntry, "JournalEntries")
+
+    # --- Servicio Post-Venta ---
+
+    @property
+    def service_calls(self) -> "AsyncGenericResource[ServiceCall]":
+        """Convenience alias for get_resource(ServiceCall, 'ServiceCalls')."""
+        from b1sl.b1sl.models._generated.entities.sales import ServiceCall
+
+        return self.get_resource(ServiceCall, "ServiceCalls")
+
+    # --- CRM & Seguimiento ---
+
+    @property
+    def activities(self) -> "AsyncGenericResource[Activity]":
+        """Convenience alias for get_resource(Activity, 'Activities')."""
+        from b1sl.b1sl.models._generated.entities.businesspartners import Activity
+
+        return self.get_resource(Activity, "Activities")
+
+    def udo(self, table_name: str) -> "AsyncUDOResource":
+        """
+        Asynchronously access a User Defined Object (UDO) or User Table.
+
+        AI Role: Dynamic accessor for entities not pre-defined in the client.
+
+        Args:
+            table_name (str): The UDO name in SAP B1.
+
+        Returns:
+            AsyncUDOResource: A resource object bound to the UDO.
+        """
+        from b1sl.b1sl.resources.udo import AsyncUDOResource
+
+        return AsyncUDOResource(adapter=self._adapter, table_name=table_name)
+
+