b1sl-python 0.1.0__py3-none-any.whl

b1sl/saphdb/tests/test_02_odbc_adapter.py

@@ -0,0 +1,96 @@
+import logging
+from datetime import timedelta
+
+from django.conf import settings
+from django.test import TestCase
+
+from b1sl.saphdb.odbc_adapter import HDBCliAdapter
+
+# from b1sl.b1sl.models.result import Result
+
+
+class RestAdapterTestCase(TestCase):
+    # TODO: Create a new RestAdapter do not use rest_adapter for testing.
+    def setUp(self) -> None:
+        self.CONNECTION_TIMEOUT_SECONDS = 2
+        # self.odbc_adapter = odbc_adapter
+        self.odbc_adapter = HDBCliAdapter(
+            address=settings.SAPODBCLIENT_ADDRESS,
+            port=settings.SAPODBCLIENT_PORT,
+            user=settings.SAPODBCLIENT_USER,
+            password=settings.SAPODBCLIENT_PASSWORD,
+            logger=logging.getLogger("test_saphdbcli"),
+            reuse_connection=True,
+            connection_timeout=timedelta(seconds=self.CONNECTION_TIMEOUT_SECONDS),
+        )
+
+    def test_01_connect_success(self):
+        self.odbc_adapter.connect()
+        self.assertIsNotNone(self.odbc_adapter.connection)
+        self.assertIsNotNone(self.odbc_adapter.connection_expiry)
+        self.assertFalse(self.odbc_adapter._is_connection_expired())
+        print("test_connect_success: Connection established successfully.")
+
+    # def test_02_connection_expiration(self):
+    #     self.odbc_adapter.connect()
+    #     self.assertIsNotNone(self.odbc_adapter.connection)
+    #     print(f"test_connection_expiration: now {self.odbc_adapter.now()}")
+    #     print(f"test_connection_expiration: expiration {self.odbc_adapter.connection_expiry}")
+    #     time.sleep(self.CONNECTION_TIMEOUT_SECONDS + 6)
+    #     print(f"test_connection_expiration: now {self.odbc_adapter.now()}")
+    #     self.assertTrue(self.odbc_adapter._is_connection_expired())
+    #     print("test_connection_expiration: Connection expired as expected.")
+
+    # def test_03_reuse_connection_true(self):
+    #     self.odbc_adapter.reuse_connection = True
+    #     self.odbc_adapter.connect()
+    #     first_connection = self.odbc_adapter.connection
+    #     self.odbc_adapter.connect()
+    #     self.assertEqual(first_connection, self.odbc_adapter.connection)
+    #     print("test_reuse_connection_true: Connection reused successfully.")
+
+    # def test_04_reuse_connection_false(self):
+    #     self.odbc_adapter.reuse_connection = False
+    #     self.odbc_adapter.connect()
+    #     first_connection = self.odbc_adapter.connection
+    #     self.odbc_adapter.connect()
+    #     self.assertNotEqual(first_connection, self.odbc_adapter.connection)
+    #     print("test_reuse_connection_false: New connection established as expected.")
+
+    def test_05_query_correct_response(self):
+        self.odbc_adapter.connect()
+        query = """
+        SELECT TOP 10 T0."ItemName" 
+        FROM "OITM" T0
+        """
+        result = self.odbc_adapter.execute_query(
+            query=query, schema=self.odbc_adapter.schema
+        )
+        print(result)  # Muestra el resultado en formato JSON
+        self.assertIsNotNone(result)
+        self.assertEqual(result.status_code, 200, "Status 200")
+
+    def test_06_query_error_response(self):
+        self.odbc_adapter.connect()
+        query = """
+        SELECT TOP 10 T0."ItemName" 
+        FROM "OITM" T0
+        """
+        result = self.odbc_adapter.execute_query(
+            query=query, schema="NON_EXISTENT_SCHEMA"
+        )
+        print(result)  # Muestra el resultado en formato JSON
+        self.assertIsNotNone(result)
+        self.assertEqual(result.status_code, 500, "Status 500")
+
+    def test_07_query_serial(self):
+        self.odbc_adapter.connect()
+        # query = """SELECT TOP 20 T0."AbsEntry", T0."QuantOut", T1."WhsCode" FROM OSRN T0 INNER JOIN OSRI T1 ON (T0."ItemCode" = T1."ItemCode") AND (T1."SuppSerial" = T0."MnfSerial") AND (T0."SysNumber" = T1."SysSerial") ORDER BY T0."AbsEntry" DESC"""
+        # query = """SELECT T0."AbsEntry", T0."QuantOut", T1."WhsCode" FROM OSRN T0 INNER JOIN OSRI T1 ON (T0."ItemCode" = T1."ItemCode") AND (T1."SuppSerial" = T0."MnfSerial") AND (T0."SysNumber" = T1."SysSerial")  WHERE T0."AbsEntry" IN ('8152')"""
+        query = """SELECT T0."AbsEntry", T0."Quantity", T1."WhsCode" FROM OSRN T0 INNER JOIN OSRI T1 ON (T0."ItemCode" = T1."ItemCode") AND (T1."SuppSerial" = T0."MnfSerial") AND (T0."SysNumber" = T1."SysSerial")  WHERE T0."AbsEntry" = ?"""
+        result = self.odbc_adapter.execute_query(
+            query=query, params=("8152",), schema=self.odbc_adapter.schema
+        )
+        print(result)  # Muestra el resultado en formato JSON
+        self.assertIsNotNone(result)
+        self.assertEqual(result.status_code, 200, "Status 200")

b1sl/saphdb/tests/test_04_serialnumberdetails_endpoint.py

@@ -0,0 +1,131 @@
+from datetime import timedelta
+from decimal import Decimal
+
+from django.test import TestCase
+
+from b1sl.saphdb.endpoints.serialnumberdetailodbc import (
+    SerialNumberDetailsODBCEndpoint,
+)
+from b1sl.saphdb.models.serial import SerialNumberList
+
+
+class SerialnumberdetailsTestCase(TestCase):
+    previous_test_passed = True
+
+    doc_entry = None
+    warehouse = None
+    quantity_out = None
+    # in_stock = None
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+        cls.serialnumberdetail_endpoint = SerialNumberDetailsODBCEndpoint()
+        cls.serialnumberdetail_endpoint.adapter.reuse_connection = True
+        cls.serialnumberdetail_endpoint.adapter.connection_timeout = timedelta(
+            seconds=30
+        )
+        cls.serialnumberdetail_endpoint.adapter.connect()
+
+        cls.doc_entry = 8152
+        cls.warehouse = "100"
+        cls.quantity_out = Decimal("0")
+
+        cls.serialnumberdetail_data = {
+            "doc_entry": cls.doc_entry,
+            "warehouse": cls.warehouse,
+            "quantity_out": cls.quantity_out,
+        }
+
+    @classmethod
+    def tearDownClass(cls):
+        # Clean up any necessary resources
+        cls.serialnumberdetail_endpoint.adapter.close()
+        super().tearDownClass()
+
+    def setUp(self):
+        pass
+
+    def check_previous_test(self):
+        if not SerialnumberdetailsTestCase.previous_test_passed:
+            self.skipTest("Previous test failed. Skipping this test.")
+
+    def test_01_get_serialnumberdetail_by_id_real_data(self):
+        self.check_previous_test()
+
+        try:
+            serialnumberdetail_response = self.serialnumberdetail_endpoint.get_by_id(
+                self.doc_entry
+            )
+            self.assertIsNotNone(serialnumberdetail_response)
+            self.assertIsInstance(serialnumberdetail_response, SerialNumberList)
+            self.assertEqual(serialnumberdetail_response.doc_entry, self.doc_entry)
+            self.assertEqual(serialnumberdetail_response.warehouse, self.warehouse)
+            print(
+                f"test_01_get_serialnumberdetail_by_id_real_data: serial retrieved with doc_entry: {self.doc_entry}"
+            )
+            SerialnumberdetailsTestCase.previous_test_passed = True
+
+        except AssertionError as e:
+            SerialnumberdetailsTestCase.previous_test_passed = False
+            raise e
+
+    def test_02_get_serialnumberdetail_by_ids_real_data(self):
+        self.check_previous_test()
+
+        try:
+            # Lista de IDs a consultar
+            serial_list = [
+                "8157",
+                "8155",
+                "8154",
+                "8153",
+                "8152",
+                "8151",
+                "8150",
+                "8149",
+                "8148",
+                "8147",
+                "8146",
+                "8145",
+                "8144",
+                "8143",
+                "8142",
+                "8141",
+                "8140",
+                "8139",
+                "8138",
+                "8137",
+            ]
+
+            # Realiza la consulta utilizando el endpoint
+            serialnumberdetail_response = self.serialnumberdetail_endpoint.get_by_ids(
+                serial_list
+            )
+
+            # Verifica que la respuesta no sea nula
+            self.assertIsNotNone(serialnumberdetail_response)
+
+            # Verifica que la respuesta sea una lista
+            self.assertIsInstance(serialnumberdetail_response, list)
+
+            # Verifica que cada elemento de la lista sea una instancia de SerialNumberList
+            for serial in serialnumberdetail_response:
+                self.assertIsInstance(serial, SerialNumberList)
+
+            # Opcional: Verifica que todos los AbsEntries en la respuesta estén en la lista original
+            abs_entries_in_response = [
+                serial.doc_entry for serial in serialnumberdetail_response
+            ]
+            for abs_entry in abs_entries_in_response:
+                self.assertIn(str(abs_entry), serial_list)
+
+            print(
+                "test_02_get_serialnumberdetail_by_ids_real_data: all serial numbers retrieved successfully."
+            )
+            SerialnumberdetailsTestCase.previous_test_passed = True
+
+        except AssertionError as e:
+            SerialnumberdetailsTestCase.previous_test_passed = False
+            raise e

b1sl_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: b1sl-python
+Version: 0.1.0
+Summary: A framework-agnostic Python SDK for SAP Business One Service Layer and SAP HANA. (Unofficial)
+Author: Eliceo Guzman
+License: MIT
+License-File: LICENSE
+Keywords: erp,hana,odata,sap,sap-b1,service-layer
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: <3.13,>=3.11
+Requires-Dist: httpx<1,>=0.28.1
+Requires-Dist: pydantic<3,>=2.0.0
+Requires-Dist: python-dotenv>=1.2.2
+Provides-Extra: all
+Requires-Dist: b1sl[django,generator,hana]; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.3.0; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-django; extra == 'dev'
+Requires-Dist: pytest-recording>=0.13.4; extra == 'dev'
+Requires-Dist: pytest<9.0,>=8.0; extra == 'dev'
+Requires-Dist: python-dotenv>=1.2.2; extra == 'dev'
+Requires-Dist: responses>=0.26.0; extra == 'dev'
+Requires-Dist: respx>=0.22.0; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: django
+Requires-Dist: django<6,>=4.2; extra == 'django'
+Provides-Extra: generator
+Requires-Dist: beautifulsoup4>=4.14.3; extra == 'generator'
+Requires-Dist: lxml>=6.0.2; extra == 'generator'
+Provides-Extra: hana
+Requires-Dist: hdbcli<3,>=2.20.0; extra == 'hana'
+Description-Content-Type: text/markdown
+
+# b1sl
+### Modern, async-first Python SDK for SAP Business One Service Layer.
+
+![b1sl Banner](docs/assets/hero_banner.png)
+
+[![Python Version](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![Pydantic v2](https://img.shields.io/badge/Pydantic-v2-orange.svg)](https://docs.pydantic.dev/)
+[![Built with httpx](https://img.shields.io/badge/HTTP-httpx-blueviolet.svg)](https://www.python-httpx.org/)
+
+b1sl is a high-performance SDK designed for the SAP B1 Service Layer, focusing on concurrency, type safety, and efficient session management.
+
+---
+
+## Key Features
+
+*   **Async-First Architecture**: Built on top of `httpx` for non-blocking I/O.
+*   **Type Safety**: Full Pydantic v2 integration for all SAP entities.
+*   **Smart Session Management**: Automatic 401 re-authentication with internal locking to prevent license exhaustion.
+*   **Session Hydration**: Reuse existing `B1SESSION` IDs across serverless functions or Temporal activities.
+*   **Optimistic Concurrency**: Automated ETag handling with smart cache invalidation on 412 conflicts.
+*   **Observability**: Structured logging and event hooks for performance monitoring.
+
+---
+
+## Installation
+
+```bash
+# Using pip
+pip install b1sl
+
+# Using uv
+uv add b1sl
+```
+
+---
+
+## Quick Start
+
+```python
+import asyncio
+from b1sl.b1sl import AsyncB1Client, B1Config
+
+async def main():
+    config = B1Config.from_env() 
+    
+    async with AsyncB1Client(config) as b1:
+        # Full type hints for items and major entities
+        item = await b1.items.get("C1000")
+        print(f"Item: {item.ItemName}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+---
+
+## Advanced Usage: FastAPI Integration
+
+b1sl is optimized for modern web frameworks. We recommend using the Lifespan pattern to share a single connection pool:
+
+```python
+from fastapi import FastAPI
+from contextlib import asynccontextmanager
+from b1sl.b1sl import AsyncB1Client, B1Config
+
+b1_client = None
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global b1_client
+    config = B1Config.from_env()
+    b1_client = AsyncB1Client(config)
+    await b1_client.connect()
+    yield
+    await b1_client.aclose()
+
+app = FastAPI(lifespan=lifespan)
+
+@app.get("/items/{item_code}")
+async def get_item(item_code: str):
+    return await b1_client.items.get(item_code)
+```
+
+---
+
+## Architecture Overview
+
+| Feature | Implementation | Benefit |
+| :--- | :--- | :--- |
+| **HTTP Engine** | `httpx` (Async/Sync) | Superior performance & timeouts |
+| **Data Models** | `Pydantic v2` | Instant validation & IDE autocomplete |
+| **Auth** | Auto-retry 401 & Hydration | Zero-downtime session management |
+| **Concurrency** | Shared Connection Pool | Prevents SAP License Exhaustion |
+
+---
+
+## Why b1sl?
+
+In production environments, SAP Business One Service Layer is sensitive to session limits and licensing costs. Traditional wrappers often create redundant connections, leading to overhead and frequent auth failures. 
+
+**b1sl** addresses these issues through:
+1. **Session Persistence**: Maintaining long-lived sessions and performing atomic re-authentication.
+2. **Resource Efficiency**: Validated Pydantic models reduce runtime exceptions and memory footprint.
+3. **Concurrency Control**: Internal locking ensures that concurrent requests wait for a single login attempt instead of triggering multiple auth calls.
+
+---
+
+## SAP Compatibility
+
+This SDK is optimized for modern Service Layer environments and defaults to **v2 (OData V4)**.
+
+*   **Verified Baseline**: Service Layer **1.27** (SAP 10.0 FP 2405).
+*   **Minimum for ETags**: Requires Service Layer **1.21+** (March 2021).
+*   **Backward Compatibility**: Supports **v1 (OData V2)** through client configuration.
+
+For a detailed history of Service Layer features and specific version support, see the [Full Compatibility Timeline](docs/01-compatibility.md).
+
+---
+
+## Contributing
+
+Contributions are welcome. Please open an issue to discuss proposed changes before submitting a pull request.
+
+---
+
+## License
+
+MIT © 2026.