datalogic-sdk 0.1.0__tar.gz

datalogic_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: datalogic-sdk
+Version: 0.1.0
+Summary: Python SDK for Datalogics shipping API
+Author: Datalogic SDK contributors
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+
+# datalogic-sdk
+
+Python SDK for the Datalogics shipping API.
+
+## Documentation
+
+- [Usage guide](docs/usage.md): how to use this Python SDK.
+- [SDK API reference](docs/api.md): Python classes, methods, return values, and exceptions.
+- [OpenAPI contract](docs/openapi.yaml): raw Datalogics HTTP API contract for
+  `POST /rest/w_create_shipping`.
+
+The OpenAPI file documents the vendor HTTP endpoint, not the Python SDK itself.
+It is included as a reference for API tooling, contract review, mock servers, or
+future code generation. The SDK does not load it at runtime.
+
+## Installation
+
+From this repository:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install .
+```
+
+This project currently has no third-party runtime dependencies. The
+`requirements.txt` file is intentionally empty except for a comment.
+
+If you only want to run from a checkout without installing:
+
+```bash
+PYTHONPATH=src python -m unittest discover -s tests
+```
+
+## Development
+
+Install the SDK and dev tooling inside a virtual environment:
+
+```bash
+make install
+```
+
+Available commands:
+
+```bash
+make format
+make lint
+make typecheck
+make test
+make package
+```
+
+`make package` builds the source distribution and wheel into `dist/`.
+
+## CI/CD
+
+GitHub Actions workflows live in `.github/workflows/`.
+
+- `ci.yml` runs on pushes to `main`, pull requests to `main`, and manual
+  dispatch. It installs the package with dev tooling, then runs lint,
+  typecheck, tests, and package build across Python 3.9 through 3.13.
+- `release.yml` runs on tags matching `v*` and manual dispatch. It runs the
+  same checks, builds `dist/`, uploads the distribution files as a workflow
+  artifact, creates a GitHub Release for tag builds, and publishes to PyPI
+  through Trusted Publishing.
+- PyPI publishing does not use a stored API token. Configure a pending trusted
+  publisher in PyPI with these values:
+  - PyPI project name: `datalogic-sdk`
+  - Owner: `yair-ros`
+  - Repository name: `datalogic-sdk`
+  - Workflow name: `release.yml`
+  - Environment name: `pypi`
+
+To create a GitHub Release, bump the version in `pyproject.toml`, then push a
+matching tag:
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+## Usage
+
+```python
+from datalogic_sdk import DatalogicClient, Order, Origin, ShippingDetails
+
+client = DatalogicClient("YOUR_AUTHENTICATION_TOKEN")
+
+response = client.create_shipping(
+    order=Order(
+        id=123,
+        number="ORD-123",
+        shipping=ShippingDetails(
+            street="Herzl",
+            city="Tel Aviv",
+            first_name="Dana",
+            last_name="Cohen",
+            postcode="6100000",
+            house="10",
+            apartment="3",
+            phone="0501234567",
+            # Use n_code only when the customer chose a pickup location.
+            n_code="PICKUP_LOCATION_ID",
+        ),
+        comment="Leave at reception",
+    ),
+    origin=Origin(
+        contract="1234",
+        company_name="Acme Ltd",
+        city="Jerusalem",
+        street="Jaffa",
+        house="1",
+        phone="021234567",
+        email="ops@example.com",
+    ),
+)
+
+print(response.status_code)
+print(response.data)
+```
+
+## Validation
+
+The SDK validates the request before sending it:
+
+- `token` is required.
+- `order.id` and `order.number` are required.
+- Required shipping fields: `street`, `city`, `first_name`, `last_name`, `house`, `phone`.
+- Optional shipping fields: `postcode`, `apartment`, `n_code`.
+- `origin.contract` must be exactly 4 characters.
+- Required origin fields: `company_name`, `city`, `street`, `house`, `phone`, `email`.
+
+## Error Handling
+
+```python
+from datalogic_sdk import DatalogicAPIError, DatalogicValidationError
+
+try:
+    response = client.create_shipping(order=order, origin=origin)
+except DatalogicValidationError as exc:
+    print(f"Invalid request: {exc}")
+except DatalogicAPIError as exc:
+    print(f"API error {exc.status_code}: {exc.response_body}")
+```
+
+## Endpoint
+
+By default the client calls:
+
+```text
+https://connect.datalogics.co.il/rest/w_create_shipping
+```
+
+You can override the base URL for testing:
+
+```python
+client = DatalogicClient("token", base_url="https://example.test")
+```

datalogic_sdk-0.1.0/README.md

@@ -0,0 +1,158 @@
+# datalogic-sdk
+
+Python SDK for the Datalogics shipping API.
+
+## Documentation
+
+- [Usage guide](docs/usage.md): how to use this Python SDK.
+- [SDK API reference](docs/api.md): Python classes, methods, return values, and exceptions.
+- [OpenAPI contract](docs/openapi.yaml): raw Datalogics HTTP API contract for
+  `POST /rest/w_create_shipping`.
+
+The OpenAPI file documents the vendor HTTP endpoint, not the Python SDK itself.
+It is included as a reference for API tooling, contract review, mock servers, or
+future code generation. The SDK does not load it at runtime.
+
+## Installation
+
+From this repository:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install .
+```
+
+This project currently has no third-party runtime dependencies. The
+`requirements.txt` file is intentionally empty except for a comment.
+
+If you only want to run from a checkout without installing:
+
+```bash
+PYTHONPATH=src python -m unittest discover -s tests
+```
+
+## Development
+
+Install the SDK and dev tooling inside a virtual environment:
+
+```bash
+make install
+```
+
+Available commands:
+
+```bash
+make format
+make lint
+make typecheck
+make test
+make package
+```
+
+`make package` builds the source distribution and wheel into `dist/`.
+
+## CI/CD
+
+GitHub Actions workflows live in `.github/workflows/`.
+
+- `ci.yml` runs on pushes to `main`, pull requests to `main`, and manual
+  dispatch. It installs the package with dev tooling, then runs lint,
+  typecheck, tests, and package build across Python 3.9 through 3.13.
+- `release.yml` runs on tags matching `v*` and manual dispatch. It runs the
+  same checks, builds `dist/`, uploads the distribution files as a workflow
+  artifact, creates a GitHub Release for tag builds, and publishes to PyPI
+  through Trusted Publishing.
+- PyPI publishing does not use a stored API token. Configure a pending trusted
+  publisher in PyPI with these values:
+  - PyPI project name: `datalogic-sdk`
+  - Owner: `yair-ros`
+  - Repository name: `datalogic-sdk`
+  - Workflow name: `release.yml`
+  - Environment name: `pypi`
+
+To create a GitHub Release, bump the version in `pyproject.toml`, then push a
+matching tag:
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+## Usage
+
+```python
+from datalogic_sdk import DatalogicClient, Order, Origin, ShippingDetails
+
+client = DatalogicClient("YOUR_AUTHENTICATION_TOKEN")
+
+response = client.create_shipping(
+    order=Order(
+        id=123,
+        number="ORD-123",
+        shipping=ShippingDetails(
+            street="Herzl",
+            city="Tel Aviv",
+            first_name="Dana",
+            last_name="Cohen",
+            postcode="6100000",
+            house="10",
+            apartment="3",
+            phone="0501234567",
+            # Use n_code only when the customer chose a pickup location.
+            n_code="PICKUP_LOCATION_ID",
+        ),
+        comment="Leave at reception",
+    ),
+    origin=Origin(
+        contract="1234",
+        company_name="Acme Ltd",
+        city="Jerusalem",
+        street="Jaffa",
+        house="1",
+        phone="021234567",
+        email="ops@example.com",
+    ),
+)
+
+print(response.status_code)
+print(response.data)
+```
+
+## Validation
+
+The SDK validates the request before sending it:
+
+- `token` is required.
+- `order.id` and `order.number` are required.
+- Required shipping fields: `street`, `city`, `first_name`, `last_name`, `house`, `phone`.
+- Optional shipping fields: `postcode`, `apartment`, `n_code`.
+- `origin.contract` must be exactly 4 characters.
+- Required origin fields: `company_name`, `city`, `street`, `house`, `phone`, `email`.
+
+## Error Handling
+
+```python
+from datalogic_sdk import DatalogicAPIError, DatalogicValidationError
+
+try:
+    response = client.create_shipping(order=order, origin=origin)
+except DatalogicValidationError as exc:
+    print(f"Invalid request: {exc}")
+except DatalogicAPIError as exc:
+    print(f"API error {exc.status_code}: {exc.response_body}")
+```
+
+## Endpoint
+
+By default the client calls:
+
+```text
+https://connect.datalogics.co.il/rest/w_create_shipping
+```
+
+You can override the base URL for testing:
+
+```python
+client = DatalogicClient("token", base_url="https://example.test")
+```

datalogic_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "datalogic-sdk"
+version = "0.1.0"
+description = "Python SDK for Datalogics shipping API"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+  { name = "Datalogic SDK contributors" }
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Typing :: Typed",
+]
+
+[project.optional-dependencies]
+dev = [
+  "build>=1.2",
+  "mypy>=1.10",
+  "ruff>=0.5",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+datalogic_sdk = ["py.typed"]
+
+[tool.mypy]
+python_version = "3.9"
+strict = true
+files = ["src"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

datalogic_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

datalogic_sdk-0.1.0/src/datalogic_sdk/__init__.py

@@ -0,0 +1,20 @@
+"""Python SDK for the Datalogics shipping API."""
+
+from datalogic_sdk.client import DatalogicClient, DatalogicResponse
+from datalogic_sdk.exceptions import (
+    DatalogicAPIError,
+    DatalogicError,
+    DatalogicValidationError,
+)
+from datalogic_sdk.models import Order, Origin, ShippingDetails
+
+__all__ = [
+    "DatalogicAPIError",
+    "DatalogicClient",
+    "DatalogicError",
+    "DatalogicResponse",
+    "DatalogicValidationError",
+    "Order",
+    "Origin",
+    "ShippingDetails",
+]

datalogic_sdk-0.1.0/src/datalogic_sdk/client.py

@@ -0,0 +1,161 @@
+"""HTTP client for the Datalogics shipping API."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, Protocol
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+from datalogic_sdk.exceptions import DatalogicAPIError, DatalogicValidationError
+from datalogic_sdk.models import Order, Origin
+
+DEFAULT_BASE_URL = "https://connect.datalogics.co.il"
+CREATE_SHIPPING_PATH = "/rest/w_create_shipping"
+
+
+@dataclass(frozen=True)
+class DatalogicResponse:
+    """Successful response returned by the Datalogics API."""
+
+    status_code: int
+    data: Any
+    text: str
+    headers: Mapping[str, str]
+
+
+@dataclass(frozen=True)
+class TransportResponse:
+    status_code: int
+    body: bytes
+    headers: Mapping[str, str]
+
+
+class Transport(Protocol):
+    def post(
+        self,
+        url: str,
+        *,
+        payload: Mapping[str, Any],
+        timeout: float,
+        headers: Mapping[str, str],
+    ) -> TransportResponse:
+        """Send a JSON POST request."""
+        ...
+
+
+class UrlLibTransport:
+    """Default transport implemented with Python's standard library."""
+
+    def post(
+        self,
+        url: str,
+        *,
+        payload: Mapping[str, Any],
+        timeout: float,
+        headers: Mapping[str, str],
+    ) -> TransportResponse:
+        body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+        request = Request(url, data=body, headers=dict(headers), method="POST")
+
+        try:
+            with urlopen(request, timeout=timeout) as response:
+                return TransportResponse(
+                    status_code=response.status,
+                    body=response.read(),
+                    headers=dict(response.headers.items()),
+                )
+        except HTTPError as exc:
+            return TransportResponse(
+                status_code=exc.code,
+                body=exc.read(),
+                headers=dict(exc.headers.items()),
+            )
+        except URLError as exc:
+            raise DatalogicAPIError(
+                f"Failed to call Datalogics API: {exc.reason}",
+                status_code=0,
+                response_body=str(exc.reason),
+            ) from exc
+
+
+class DatalogicClient:
+    """Client for Datalogics shipping operations."""
+
+    def __init__(
+        self,
+        token: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        transport: Transport | None = None,
+    ) -> None:
+        if not isinstance(token, str) or not token.strip():
+            raise DatalogicValidationError("token is required")
+        if not isinstance(base_url, str) or not base_url.strip():
+            raise DatalogicValidationError("base_url is required")
+        if timeout <= 0:
+            raise DatalogicValidationError("timeout must be greater than 0")
+
+        self._token = token
+        self._base_url = base_url.rstrip("/")
+        self._timeout = float(timeout)
+        self._transport = transport or UrlLibTransport()
+
+    def create_shipping(self, *, order: Order, origin: Origin) -> DatalogicResponse:
+        """Create a shipping order.
+
+        Raises:
+            DatalogicValidationError: Request data is invalid.
+            DatalogicAPIError: The API returns a non-2xx response or networking fails.
+        """
+
+        if not isinstance(order, Order):
+            raise DatalogicValidationError("order must be an Order instance")
+        if not isinstance(origin, Origin):
+            raise DatalogicValidationError("origin must be an Origin instance")
+
+        payload = {
+            "token": self._token,
+            "order": order.to_dict(),
+            "origin": origin.to_dict(),
+        }
+
+        response = self._transport.post(
+            f"{self._base_url}{CREATE_SHIPPING_PATH}",
+            payload=payload,
+            timeout=self._timeout,
+            headers={
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+                "User-Agent": "datalogic-sdk-python/0.1.0",
+            },
+        )
+
+        text = response.body.decode("utf-8", errors="replace")
+        data = self._parse_response_body(text)
+
+        if response.status_code < 200 or response.status_code >= 300:
+            raise DatalogicAPIError(
+                f"Datalogics API returned HTTP {response.status_code}",
+                status_code=response.status_code,
+                response_body=text,
+            )
+
+        return DatalogicResponse(
+            status_code=response.status_code,
+            data=data,
+            text=text,
+            headers=response.headers,
+        )
+
+    @staticmethod
+    def _parse_response_body(text: str) -> Any:
+        if not text:
+            return None
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            return text

datalogic_sdk-0.1.0/src/datalogic_sdk/exceptions.py

@@ -0,0 +1,18 @@
+"""Exceptions raised by datalogic-sdk."""
+
+
+class DatalogicError(Exception):
+    """Base exception for SDK errors."""
+
+
+class DatalogicValidationError(DatalogicError, ValueError):
+    """Raised when a request model contains invalid data."""
+
+
+class DatalogicAPIError(DatalogicError):
+    """Raised when the Datalogics API returns a non-success response."""
+
+    def __init__(self, message: str, *, status_code: int, response_body: str):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_body = response_body

datalogic_sdk-0.1.0/src/datalogic_sdk/models.py

@@ -0,0 +1,113 @@
+"""Request models for the Datalogics shipping API."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from datalogic_sdk.exceptions import DatalogicValidationError
+
+
+def _require_text(value: str | None, field_name: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise DatalogicValidationError(f"{field_name} is required")
+    return value
+
+
+def _require_order_value(value: int | str, field_name: str) -> int | str:
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str) and value.strip():
+        return value
+    raise DatalogicValidationError(f"{field_name} is required")
+
+
+def _optional_text(value: str | None, field_name: str) -> str | None:
+    if value is None:
+        return None
+    if not isinstance(value, str) or not value.strip():
+        raise DatalogicValidationError(f"{field_name} must be a non-empty string when provided")
+    return value
+
+
+@dataclass(frozen=True)
+class ShippingDetails:
+    """Destination details for an order shipment."""
+
+    street: str
+    city: str
+    first_name: str
+    last_name: str
+    house: str
+    phone: str
+    postcode: str | None = None
+    apartment: str | None = None
+    n_code: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        payload = {
+            "street": _require_text(self.street, "order.shipping.street"),
+            "city": _require_text(self.city, "order.shipping.city"),
+            "first_name": _require_text(self.first_name, "order.shipping.first_name"),
+            "last_name": _require_text(self.last_name, "order.shipping.last_name"),
+            "postcode": _optional_text(self.postcode, "order.shipping.postcode"),
+            "house": _require_text(self.house, "order.shipping.house"),
+            "apartment": _optional_text(self.apartment, "order.shipping.apartment"),
+            "phone": _require_text(self.phone, "order.shipping.phone"),
+            "n_code": _optional_text(self.n_code, "order.shipping.n_code"),
+        }
+        return {key: value for key, value in payload.items() if value is not None}
+
+
+@dataclass(frozen=True)
+class Order:
+    """Shipping order details."""
+
+    id: int | str
+    number: int | str
+    shipping: ShippingDetails
+    comment: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        if not isinstance(self.shipping, ShippingDetails):
+            raise DatalogicValidationError("order.shipping must be a ShippingDetails instance")
+
+        payload = {
+            "id": _require_order_value(self.id, "order.id"),
+            "number": _require_order_value(self.number, "order.number"),
+            "shipping": self.shipping.to_dict(),
+            "comment": _optional_text(self.comment, "order.comment"),
+        }
+        return {key: value for key, value in payload.items() if value is not None}
+
+
+@dataclass(frozen=True)
+class Origin:
+    """Origin settings for a shipping order."""
+
+    contract: str
+    company_name: str
+    city: str
+    street: str
+    house: str
+    phone: str
+    email: str
+
+    def to_dict(self) -> dict[str, Any]:
+        contract = _require_text(self.contract, "origin.contract")
+        if len(contract) != 4:
+            raise DatalogicValidationError("origin.contract must be exactly 4 characters")
+
+        email = _require_text(self.email, "origin.email")
+        if "@" not in email:
+            raise DatalogicValidationError("origin.email must be a valid email address")
+
+        return {
+            "contract": contract,
+            "company_name": _require_text(self.company_name, "origin.company_name"),
+            "city": _require_text(self.city, "origin.city"),
+            "street": _require_text(self.street, "origin.street"),
+            "house": _require_text(self.house, "origin.house"),
+            "phone": _require_text(self.phone, "origin.phone"),
+            "email": email,
+        }

datalogic_sdk-0.1.0/src/datalogic_sdk/py.typed

@@ -0,0 +1 @@
+

datalogic_sdk-0.1.0/src/datalogic_sdk.egg-info/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: datalogic-sdk
+Version: 0.1.0
+Summary: Python SDK for Datalogics shipping API
+Author: Datalogic SDK contributors
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+
+# datalogic-sdk
+
+Python SDK for the Datalogics shipping API.
+
+## Documentation
+
+- [Usage guide](docs/usage.md): how to use this Python SDK.
+- [SDK API reference](docs/api.md): Python classes, methods, return values, and exceptions.
+- [OpenAPI contract](docs/openapi.yaml): raw Datalogics HTTP API contract for
+  `POST /rest/w_create_shipping`.
+
+The OpenAPI file documents the vendor HTTP endpoint, not the Python SDK itself.
+It is included as a reference for API tooling, contract review, mock servers, or
+future code generation. The SDK does not load it at runtime.
+
+## Installation
+
+From this repository:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install .
+```
+
+This project currently has no third-party runtime dependencies. The
+`requirements.txt` file is intentionally empty except for a comment.
+
+If you only want to run from a checkout without installing:
+
+```bash
+PYTHONPATH=src python -m unittest discover -s tests
+```
+
+## Development
+
+Install the SDK and dev tooling inside a virtual environment:
+
+```bash
+make install
+```
+
+Available commands:
+
+```bash
+make format
+make lint
+make typecheck
+make test
+make package
+```
+
+`make package` builds the source distribution and wheel into `dist/`.
+
+## CI/CD
+
+GitHub Actions workflows live in `.github/workflows/`.
+
+- `ci.yml` runs on pushes to `main`, pull requests to `main`, and manual
+  dispatch. It installs the package with dev tooling, then runs lint,
+  typecheck, tests, and package build across Python 3.9 through 3.13.
+- `release.yml` runs on tags matching `v*` and manual dispatch. It runs the
+  same checks, builds `dist/`, uploads the distribution files as a workflow
+  artifact, creates a GitHub Release for tag builds, and publishes to PyPI
+  through Trusted Publishing.
+- PyPI publishing does not use a stored API token. Configure a pending trusted
+  publisher in PyPI with these values:
+  - PyPI project name: `datalogic-sdk`
+  - Owner: `yair-ros`
+  - Repository name: `datalogic-sdk`
+  - Workflow name: `release.yml`
+  - Environment name: `pypi`
+
+To create a GitHub Release, bump the version in `pyproject.toml`, then push a
+matching tag:
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+## Usage
+
+```python
+from datalogic_sdk import DatalogicClient, Order, Origin, ShippingDetails
+
+client = DatalogicClient("YOUR_AUTHENTICATION_TOKEN")
+
+response = client.create_shipping(
+    order=Order(
+        id=123,
+        number="ORD-123",
+        shipping=ShippingDetails(
+            street="Herzl",
+            city="Tel Aviv",
+            first_name="Dana",
+            last_name="Cohen",
+            postcode="6100000",
+            house="10",
+            apartment="3",
+            phone="0501234567",
+            # Use n_code only when the customer chose a pickup location.
+            n_code="PICKUP_LOCATION_ID",
+        ),
+        comment="Leave at reception",
+    ),
+    origin=Origin(
+        contract="1234",
+        company_name="Acme Ltd",
+        city="Jerusalem",
+        street="Jaffa",
+        house="1",
+        phone="021234567",
+        email="ops@example.com",
+    ),
+)
+
+print(response.status_code)
+print(response.data)
+```
+
+## Validation
+
+The SDK validates the request before sending it:
+
+- `token` is required.
+- `order.id` and `order.number` are required.
+- Required shipping fields: `street`, `city`, `first_name`, `last_name`, `house`, `phone`.
+- Optional shipping fields: `postcode`, `apartment`, `n_code`.
+- `origin.contract` must be exactly 4 characters.
+- Required origin fields: `company_name`, `city`, `street`, `house`, `phone`, `email`.
+
+## Error Handling
+
+```python
+from datalogic_sdk import DatalogicAPIError, DatalogicValidationError
+
+try:
+    response = client.create_shipping(order=order, origin=origin)
+except DatalogicValidationError as exc:
+    print(f"Invalid request: {exc}")
+except DatalogicAPIError as exc:
+    print(f"API error {exc.status_code}: {exc.response_body}")
+```
+
+## Endpoint
+
+By default the client calls:
+
+```text
+https://connect.datalogics.co.il/rest/w_create_shipping
+```
+
+You can override the base URL for testing:
+
+```python
+client = DatalogicClient("token", base_url="https://example.test")
+```

datalogic_sdk-0.1.0/src/datalogic_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/datalogic_sdk/__init__.py
+src/datalogic_sdk/client.py
+src/datalogic_sdk/exceptions.py
+src/datalogic_sdk/models.py
+src/datalogic_sdk/py.typed
+src/datalogic_sdk.egg-info/PKG-INFO
+src/datalogic_sdk.egg-info/SOURCES.txt
+src/datalogic_sdk.egg-info/dependency_links.txt
+src/datalogic_sdk.egg-info/requires.txt
+src/datalogic_sdk.egg-info/top_level.txt
+tests/test_client.py

datalogic_sdk-0.1.0/src/datalogic_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

datalogic_sdk-0.1.0/src/datalogic_sdk.egg-info/requires.txt

@@ -0,0 +1,5 @@
+
+[dev]
+build>=1.2
+mypy>=1.10
+ruff>=0.5

datalogic_sdk-0.1.0/src/datalogic_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+datalogic_sdk

datalogic_sdk-0.1.0/tests/test_client.py

@@ -0,0 +1,137 @@
+import unittest
+
+from datalogic_sdk import (
+    DatalogicAPIError,
+    DatalogicClient,
+    DatalogicValidationError,
+    Order,
+    Origin,
+    ShippingDetails,
+)
+from datalogic_sdk.client import TransportResponse
+
+
+class FakeTransport:
+    def __init__(self, response):
+        self.response = response
+        self.calls = []
+
+    def post(self, url, *, payload, timeout, headers):
+        self.calls.append(
+            {
+                "url": url,
+                "payload": payload,
+                "timeout": timeout,
+                "headers": headers,
+            }
+        )
+        return self.response
+
+
+def valid_order():
+    return Order(
+        id=123,
+        number="ORD-123",
+        shipping=ShippingDetails(
+            street="Herzl",
+            city="Tel Aviv",
+            first_name="Dana",
+            last_name="Cohen",
+            house="10",
+            apartment="3",
+            phone="0501234567",
+            n_code="PICKUP-1",
+        ),
+        comment="Leave at reception",
+    )
+
+
+def valid_origin():
+    return Origin(
+        contract="1234",
+        company_name="Acme",
+        city="Jerusalem",
+        street="Jaffa",
+        house="1",
+        phone="021234567",
+        email="ops@example.com",
+    )
+
+
+class DatalogicClientTests(unittest.TestCase):
+    def test_create_shipping_posts_expected_payload(self):
+        transport = FakeTransport(
+            TransportResponse(
+                status_code=200,
+                body=b'{"success": true, "barcode": "ABC"}',
+                headers={"Content-Type": "application/json"},
+            )
+        )
+        client = DatalogicClient("token-123", transport=transport)
+
+        response = client.create_shipping(order=valid_order(), origin=valid_origin())
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["barcode"], "ABC")
+        self.assertEqual(len(transport.calls), 1)
+        call = transport.calls[0]
+        self.assertEqual(call["url"], "https://connect.datalogics.co.il/rest/w_create_shipping")
+        self.assertEqual(call["headers"]["Content-Type"], "application/json")
+        self.assertEqual(call["payload"]["token"], "token-123")
+        self.assertEqual(call["payload"]["order"]["shipping"]["n_code"], "PICKUP-1")
+        self.assertEqual(call["payload"]["origin"]["contract"], "1234")
+
+    def test_optional_none_fields_are_omitted(self):
+        order = Order(
+            id=123,
+            number=456,
+            shipping=ShippingDetails(
+                street="Herzl",
+                city="Tel Aviv",
+                first_name="Dana",
+                last_name="Cohen",
+                house="10",
+                phone="0501234567",
+            ),
+        )
+        transport = FakeTransport(TransportResponse(status_code=200, body=b"{}", headers={}))
+        client = DatalogicClient("token-123", transport=transport)
+
+        client.create_shipping(order=order, origin=valid_origin())
+
+        payload = transport.calls[0]["payload"]
+        self.assertNotIn("comment", payload["order"])
+        self.assertNotIn("postcode", payload["order"]["shipping"])
+        self.assertNotIn("apartment", payload["order"]["shipping"])
+        self.assertNotIn("n_code", payload["order"]["shipping"])
+
+    def test_contract_must_be_four_characters(self):
+        origin = Origin(
+            contract="12345",
+            company_name="Acme",
+            city="Jerusalem",
+            street="Jaffa",
+            house="1",
+            phone="021234567",
+            email="ops@example.com",
+        )
+        client = DatalogicClient("token-123", transport=FakeTransport(None))
+
+        with self.assertRaises(DatalogicValidationError):
+            client.create_shipping(order=valid_order(), origin=origin)
+
+    def test_non_success_response_raises_api_error(self):
+        transport = FakeTransport(
+            TransportResponse(status_code=400, body=b'{"error": "bad request"}', headers={})
+        )
+        client = DatalogicClient("token-123", transport=transport)
+
+        with self.assertRaises(DatalogicAPIError) as context:
+            client.create_shipping(order=valid_order(), origin=valid_origin())
+
+        self.assertEqual(context.exception.status_code, 400)
+        self.assertIn("bad request", context.exception.response_body)
+
+
+if __name__ == "__main__":
+    unittest.main()