bapp-api-client 0.2.0__tar.gz

bapp_api_client-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,53 @@
+name: Publish to PyPI
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write  # Required for trusted publishing
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+
+      - name: Check if version changed
+        id: version
+        run: |
+          NEW_VERSION=$(python -c "
+          import tomllib
+          with open('pyproject.toml', 'rb') as f:
+              print(tomllib.load(f)['project']['version'])
+          ")
+          OLD_VERSION=$(git show HEAD~1:pyproject.toml | python -c "
+          import tomllib, sys
+          print(tomllib.load(sys.stdin.buffer)['project']['version'])
+          " 2>/dev/null || echo "")
+          echo "new=$NEW_VERSION" >> "$GITHUB_OUTPUT"
+          echo "old=$OLD_VERSION" >> "$GITHUB_OUTPUT"
+          if [ "$NEW_VERSION" != "$OLD_VERSION" ]; then
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+            echo "Version changed: $OLD_VERSION -> $NEW_VERSION"
+          else
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+            echo "Version unchanged: $NEW_VERSION"
+          fi
+
+      - name: Set up Python
+        if: steps.version.outputs.changed == 'true'
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build package
+        if: steps.version.outputs.changed == 'true'
+        run: |
+          pip install build
+          python -m build
+
+      - name: Publish to PyPI
+        if: steps.version.outputs.changed == 'true'
+        uses: pypa/gh-action-pypi-publish@release/v1

bapp_api_client-0.2.0/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 0.2.0
+
+- Initial release.
+- Authentication: Bearer (JWT/OAuth) and Token (API key).
+- Entity CRUD: list, get, create, update, patch, delete.
+- Paginated list responses with metadata (count, next, previous).
+- Entity introspection: list_introspect, detail_introspect.
+- Tasks: list, detail, run (sync and async with polling).
+- Long-running task support via run_task_async with automatic polling.
+- File uploads: automatic multipart/form-data detection.

bapp_api_client-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BAPP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bapp_api_client-0.2.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: bapp-api-client
+Version: 0.2.0
+Summary: BAPP Auto API Client for Python
+Project-URL: Homepage, https://www.bapp.ro
+Project-URL: Repository, https://github.com/bapp-open/sdk-python
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,bapp,client
+Requires-Python: >=3.9
+Requires-Dist: requests>=2.20

bapp_api_client-0.2.0/README.md

@@ -0,0 +1,158 @@
+# BAPP Auto API Client — Python
+
+Official Python client for the [BAPP Auto API](https://www.bapp.ro). Provides a
+simple, consistent interface for authentication, entity CRUD, and task execution.
+
+## Getting Started
+
+### 1. Install
+
+```bash
+pip install bapp-api-client
+```
+
+### 2. Create a client
+
+```python
+from bapp_api_client import BappApiClient
+
+client = BappApiClient(token="your-api-key")
+```
+
+### 3. Make your first request
+
+```python
+# List with filters
+countries = client.list("core.country", page=1, search="Romania")
+
+# Get by ID
+country = client.get("core.country", "42")
+
+# Create
+new = client.create("core.country", {"name": "Romania", "code": "RO"})
+
+# Update (full)
+client.update("core.country", "42", {"name": "Romania", "code": "RO"})
+
+# Patch (partial)
+client.patch("core.country", "42", {"code": "RO"})
+
+# Delete
+client.delete("core.country", "42")
+```
+
+## Authentication
+
+The client supports **Token** (API key) and **Bearer** (JWT / OAuth) authentication.
+Token auth already includes a tenant binding, so you don't need to specify `tenant` separately.
+
+```python
+# Static API token (tenant is included in the token)
+client = BappApiClient(token="your-api-key")
+
+# Bearer (JWT / OAuth)
+client = BappApiClient(bearer="eyJhbG...", tenant="1")
+```
+
+## Configuration
+
+`tenant` and `app` can be changed at any time after construction:
+
+```python
+client.tenant = "2"
+client.app = "wms"
+```
+
+## API Reference
+
+### Client options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `token` | Static API token (`Token <value>`) — includes tenant | — |
+| `bearer` | Bearer / JWT token | — |
+| `host` | API base URL | `https://panel.bapp.ro/api` |
+| `tenant` | Tenant ID (`x-tenant-id` header) | `None` |
+| `app` | App slug (`x-app-slug` header) | `"account"` |
+
+### Methods
+
+| Method | Description |
+|--------|-------------|
+| `me()` | Get current user profile |
+| `get_app(app_slug)` | Get app configuration by slug |
+| `list(content_type, **filters)` | List entities (paginated) |
+| `get(content_type, id)` | Get a single entity |
+| `create(content_type, data)` | Create an entity |
+| `update(content_type, id, data)` | Full update (PUT) |
+| `patch(content_type, id, data)` | Partial update (PATCH) |
+| `delete(content_type, id)` | Delete an entity |
+| `list_introspect(content_type)` | Get list view metadata |
+| `detail_introspect(content_type)` | Get detail view metadata |
+| `list_tasks()` | List available task codes |
+| `detail_task(code)` | Get task configuration |
+| `run_task(code, payload?)` | Execute a task |
+| `run_task_async(code, payload?)` | Run a long-running task and poll until done |
+
+### Paginated responses
+
+`list()` returns the results directly as a list/array. Pagination metadata is
+available as extra attributes:
+
+- `count` — total number of items across all pages
+- `next` — URL of the next page (or `null`)
+- `previous` — URL of the previous page (or `null`)
+
+## File Uploads
+
+When data contains file objects, the client automatically switches from JSON to
+`multipart/form-data`. Mix regular fields and files in the same call:
+
+```python
+# File objects, byte strings, or tuples (filename, file) are auto-detected
+client.create("myapp.document", {
+    "name": "Report",
+    "file": open("report.pdf", "rb"),
+})
+
+# Tuple form for explicit filename / content-type
+client.create("myapp.document", {
+    "name": "Report",
+    "file": ("report.pdf", open("report.pdf", "rb"), "application/pdf"),
+})
+
+# Also works with tasks
+client.run_task("myapp.import_data", {
+    "format": "csv",
+    "file": open("data.csv", "rb"),
+})
+```
+
+## Tasks
+
+Tasks are server-side actions identified by a dotted code (e.g. `myapp.export_report`).
+
+```python
+# List all tasks
+tasks = client.list_tasks()
+
+# Inspect a task
+cfg = client.detail_task("myapp.export_report")
+
+# Run without payload (GET)
+result = client.run_task("myapp.export_report")
+
+# Run with payload (POST)
+result = client.run_task("myapp.export_report", {"format": "csv"})
+```
+
+### Long-running tasks
+
+Some tasks run asynchronously on the server. When triggered, they return an `id`
+that can be polled via `bapp_framework.taskdata`. Use `run_task_async()` to
+handle this automatically — it polls until `finished` is `true` and returns the
+final task data (which includes a `file` URL when the task produces a download).
+
+## License
+
+MIT

bapp_api_client-0.2.0/bapp_api_client/__init__.py

@@ -0,0 +1,3 @@
+from .client import BappApiClient, PagedList
+
+__all__ = ["BappApiClient", "PagedList"]

bapp_api_client-0.2.0/bapp_api_client/client.py

@@ -0,0 +1,232 @@
+"""BAPP Auto API Client for Python."""
+
+import io
+import time
+import requests
+
+
+def _has_files(data):
+    """Return True if data dict contains file-like values."""
+    if not isinstance(data, dict):
+        return False
+    for v in data.values():
+        if isinstance(v, (io.IOBase, bytes, bytearray)):
+            return True
+        if hasattr(v, "read"):
+            return True
+        if isinstance(v, tuple) and len(v) >= 2:
+            return True
+    return False
+
+
+class PagedList(list):
+    """A list of results with pagination metadata.
+
+    Behaves like a normal list (iterating, indexing, len) but also exposes
+    ``count``, ``next``, and ``previous`` from the paginated API response.
+    """
+
+    def __init__(self, results, *, count=0, next=None, previous=None):
+        super().__init__(results)
+        self.count = count
+        self.next = next
+        self.previous = previous
+
+    def __repr__(self):
+        return f"PagedList(count={self.count}, len={len(self)})"
+
+
+class BappApiClient:
+    """Client for the BAPP Auto API.
+
+    Args:
+        bearer: Bearer token for authentication.
+        token: Token-based authentication (``Token <value>``).
+        host: Base URL of the API.
+        tenant: Default tenant ID sent as ``x-tenant-id`` header.
+        app: Default app slug sent as ``x-app-slug`` header.
+    """
+
+    def __init__(
+        self,
+        bearer=None,
+        token=None,
+        host="https://panel.bapp.ro/api",
+        tenant=None,
+        app="account",
+    ):
+        self.host = host.rstrip("/")
+        self.tenant = tenant
+        self.app = app
+        self._session = requests.Session()
+        if bearer:
+            self._session.headers["Authorization"] = f"Bearer {bearer}"
+        elif token:
+            self._session.headers["Authorization"] = f"Token {token}"
+
+    # -- internals -----------------------------------------------------------
+
+    def _headers(self, extra=None):
+        h = {}
+        if self.tenant is not None:
+            h["x-tenant-id"] = str(self.tenant)
+        if self.app is not None:
+            h["x-app-slug"] = self.app
+        if extra:
+            h.update(extra)
+        return h
+
+    def _request(self, method, path, params=None, json=None, headers=None):
+        kwargs = {}
+        if json is not None and _has_files(json):
+            files = {}
+            data = {}
+            for k, v in json.items():
+                if isinstance(v, (io.IOBase, bytes, bytearray)) or hasattr(v, "read"):
+                    files[k] = v
+                elif isinstance(v, tuple) and len(v) >= 2:
+                    files[k] = v
+                else:
+                    data[k] = v
+            kwargs["files"] = files
+            kwargs["data"] = data
+        else:
+            kwargs["json"] = json
+        resp = self._session.request(
+            method,
+            f"{self.host}{path}",
+            params=params,
+            headers=self._headers(headers),
+            **kwargs,
+        )
+        resp.raise_for_status()
+        if resp.status_code == 204:
+            return None
+        return resp.json()
+
+    # -- user ----------------------------------------------------------------
+
+    def me(self):
+        """Get current user profile."""
+        return self._request("GET", "/tasks/bapp_framework.me", headers={"x-app-slug": ""})
+
+    # -- app -----------------------------------------------------------------
+
+    def get_app(self, app_slug):
+        """Get app configuration by slug."""
+        return self._request(
+            "GET", "/tasks/bapp_framework.getapp", headers={"x-app-slug": app_slug}
+        )
+
+    # -- entity introspect ---------------------------------------------------
+
+    def list_introspect(self, content_type):
+        """Get entity list introspect for a content type."""
+        return self._request(
+            "GET", "/tasks/bapp_framework.listintrospect", params={"ct": content_type}
+        )
+
+    def detail_introspect(self, content_type, pk=None):
+        """Get entity detail introspect for a content type."""
+        params = {"ct": content_type}
+        if pk is not None:
+            params["pk"] = pk
+        return self._request(
+            "GET", "/tasks/bapp_framework.detailintrospect", params=params
+        )
+
+    # -- entity CRUD ---------------------------------------------------------
+
+    def list(self, content_type, **filters):
+        """List entities of a content type with optional filters.
+
+        Returns a ``PagedList`` — a regular list of results with additional
+        ``.count``, ``.next``, and ``.previous`` attributes.
+        """
+        data = self._request(
+            "GET", f"/content-type/{content_type}/", params=filters or None
+        )
+        return PagedList(
+            data.get("results", []),
+            count=data.get("count", 0),
+            next=data.get("next"),
+            previous=data.get("previous"),
+        )
+
+    def get(self, content_type, id):
+        """Get a single entity by content type and ID."""
+        return self._request("GET", f"/content-type/{content_type}/{id}/")
+
+    def create(self, content_type, data=None):
+        """Create a new entity of a content type."""
+        return self._request("POST", f"/content-type/{content_type}/", json=data)
+
+    def update(self, content_type, id, data=None):
+        """Full update of an entity."""
+        return self._request("PUT", f"/content-type/{content_type}/{id}/", json=data)
+
+    def patch(self, content_type, id, data=None):
+        """Partial update of an entity."""
+        return self._request("PATCH", f"/content-type/{content_type}/{id}/", json=data)
+
+    def delete(self, content_type, id):
+        """Delete an entity."""
+        return self._request("DELETE", f"/content-type/{content_type}/{id}/")
+
+    # -- tasks ---------------------------------------------------------------
+
+    def list_tasks(self):
+        """List all available task codes."""
+        return self._request("GET", "/tasks")
+
+    def detail_task(self, code):
+        """Get task configuration by code."""
+        return self._request("OPTIONS", f"/tasks/{code}")
+
+    def run_task(self, code, payload=None):
+        """Run a task. Uses GET when no payload, POST otherwise."""
+        if payload is None:
+            return self._request("GET", f"/tasks/{code}")
+        return self._request("POST", f"/tasks/{code}", json=payload)
+
+    def run_task_async(self, code, payload=None, poll_interval=1, timeout=300):
+        """Run a long-running task and poll until finished.
+
+        When the task returns an ``id``, the method polls
+        ``bapp_framework.taskdata`` until the task finishes (or fails).
+        Returns the final task data dict which includes ``file`` when
+        the task produces a downloadable file.
+
+        Args:
+            code: Task code.
+            payload: Task payload (triggers POST).
+            poll_interval: Seconds between polls (default 1).
+            timeout: Max seconds to wait (default 300).
+
+        Raises:
+            TimeoutError: If the task doesn't finish within *timeout*.
+            RuntimeError: If the task reports failure.
+        """
+        result = self.run_task(code, payload)
+        task_id = result.get("id") if isinstance(result, dict) else None
+        if task_id is None:
+            return result
+
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            time.sleep(poll_interval)
+            page = self._request(
+                "GET", "/content-type/bapp_framework.taskdata/",
+                params={"id": task_id},
+            )
+            results = page.get("results", [])
+            if not results:
+                continue
+            task_data = results[0]
+            if task_data.get("failed"):
+                raise RuntimeError(
+                    f"Task {code} failed: {task_data.get('message', '')}"
+                )
+            if task_data.get("finished"):
+                return task_data
+        raise TimeoutError(f"Task {code} ({task_id}) did not finish within {timeout}s")

bapp_api_client-0.2.0/pyproject.toml

@@ -0,0 +1,16 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bapp-api-client"
+version = "0.2.0"
+description = "BAPP Auto API Client for Python"
+requires-python = ">=3.9"
+license = "MIT"
+keywords = ["bapp", "api", "client"]
+dependencies = ["requests>=2.20"]
+
+[project.urls]
+Homepage = "https://www.bapp.ro"
+Repository = "https://github.com/bapp-open/sdk-python"