bazis-bulk 2.2.0__py3-none-any.whl

bazis/contrib/bulk/__init__.py

@@ -0,0 +1,19 @@
+# Copyright 2026 EcoFuture Technology Services LLC and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+try:
+    from importlib.metadata import PackageNotFoundError, version
+    __version__ = version('bazis-bulk')
+except PackageNotFoundError:
+    __version__ = 'dev'

bazis/contrib/bulk/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '2.2.0'
+__version_tuple__ = version_tuple = (2, 2, 0)
+
+__commit_id__ = commit_id = None

bazis/contrib/bulk/locale/en/LC_MESSAGES/django.po

@@ -0,0 +1,23 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2024-07-04 07:31+0000\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+
+#: routes.py:10
+msgid "Bulk requests"
+msgstr ""

bazis/contrib/bulk/locale/ru/LC_MESSAGES/django.po

@@ -0,0 +1,25 @@
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2024-07-04 07:31+0000\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
+"Language-Team: LANGUAGE <LL@li.org>\n"
+"Language: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+"Plural-Forms: nplurals=4; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
+"%10<=4 && (n%100<12 || n%100>14) ? 1 : n%10==0 || (n%10>=5 && n%10<=9) || (n"
+"%100>=11 && n%100<=14)? 2 : 3);\n"
+
+#: routes.py:10
+msgid "Bulk requests"
+msgstr "Пакетные запросы"

bazis/contrib/bulk/router.py

@@ -0,0 +1,34 @@
+# Copyright 2026 EcoFuture Technology Services LLC and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from bazis.core.app import app
+
+from .routes import router  # noqa: F401
+from .utils import threadpool_vars_prepare
+
+
+class ThreadpoolVarsPrepareMiddleware:
+    """
+    The middleware calls the initializing function for the context variables of worker threads
+    """
+
+    def __init__(self, app) -> None:
+        self.app = app
+
+    async def __call__(self, scope, receive, send) -> None:
+        threadpool_vars_prepare()
+        await self.app(scope, receive, send)
+
+
+app.add_middleware(ThreadpoolVarsPrepareMiddleware)

bazis/contrib/bulk/routes.py

@@ -0,0 +1,121 @@
+# Copyright 2026 EcoFuture Technology Services LLC and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+from urllib.parse import urlparse
+
+from django.utils.translation import gettext_lazy as _
+
+from fastapi import Request, Response
+
+from bazis.core.routing import BazisRouter
+
+from . import schemas
+from .utils import ThreadDedicated, ThreadsPool
+
+
+router = BazisRouter(tags=[_('Bulk requests')])
+
+
+class BulkRollbackError(Exception): ...
+
+
+@router.post('/bulk/', response_model=list[schemas.BulkResponseItemSchema])
+async def bulk(
+    request: Request,
+    response: Response,
+    items: list[schemas.BulkRequestItemSchema],
+    is_atomic: bool = True,
+):
+    from bazis.core.app import app
+
+    # collect the list of responses
+    results = []
+
+    if is_atomic:
+        thread_behavior = ThreadDedicated()
+    else:
+        thread_behavior = ThreadsPool()
+
+    try:
+        async with thread_behavior as thread:
+            for item in items:  # type: schemas.BulkRequestItemSchema
+                # parse the endpoint
+                url = urlparse(item.endpoint)
+
+                # build the scope
+                scope = {
+                    'type': request.scope.get('type'),
+                    'asgi': request.scope.get('asgi'),
+                    'http_version': request.scope.get('http_version'),
+                    'server': request.scope.get('server'),
+                    'client': request.scope.get('client'),
+                    'scheme': request.scope.get('scheme'),
+                    'headers': request.scope['headers'],
+                    'method': item.method.upper(),
+                    'query_string': url.query and url.query.encode(),
+                    'path': url.path,
+                    'raw_path': url.path,
+                }
+
+                # build the response
+                result = {
+                    'endpoint': item.endpoint,
+                }
+
+                async def receive(_item=item):
+                    return {
+                        'type': 'http.request',
+                        'body': json.dumps(
+                            _item.body,
+                            ensure_ascii=False,
+                            allow_nan=False,
+                        ).encode("utf-8"),
+                    }
+
+                async def sender(_data, _result=result):
+                    if _data['type'] == 'http.response.start':
+                        _result['status'] = _data['status']
+                        _result['headers'] = _data['headers']
+                    if _data['type'] == 'http.response.body':
+                        # determine the content type
+                        content_type = dict(_result['headers']).get(b'content-type')
+                        if content_type and b'json' in content_type:
+                            _result['response'] = (
+                                json.loads(_data['body']) if _data['body'] else None
+                            )
+                        else:
+                            _result['response'] = _data['body']
+
+                # run the route execution in a dedicated thread (since we are in the context of this thread)
+                await app.__call__(scope, receive, sender)
+                # if an exception occurred inside the dedicated thread - the transaction needs to be restarted
+                await thread.check()
+
+                # for any incorrect response of a package item - we make the overall package status non-working
+                if is_atomic and result['status'] >= 400:
+                    response.status_code = 400
+                results.append(result)
+
+            if not response.status_code:
+                response.status_code = 200
+
+            # if the status is non-working - roll back the transaction
+            if response.status_code >= 400:
+                raise BulkRollbackError
+
+    except BulkRollbackError:
+        pass
+
+    return results

bazis/contrib/bulk/schemas.py

@@ -0,0 +1,31 @@
+# Copyright 2026 EcoFuture Technology Services LLC and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class BulkRequestItemSchema(BaseModel):
+    endpoint: str
+    method: str = 'GET'
+    body: dict | None = None
+    headers: list[tuple[str, Any]] | None = None
+
+
+class BulkResponseItemSchema(BaseModel):
+    endpoint: str
+    status: int
+    response: str | dict | None
+    headers: list[tuple[str, Any]]

bazis/contrib/bulk/utils.py

@@ -0,0 +1,193 @@
+# Copyright 2026 EcoFuture Technology Services LLC and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import asyncio
+import sys
+from collections import deque
+from contextvars import ContextVar, copy_context
+from typing import Any
+
+from django.db import transaction
+
+from anyio._backends._asyncio import (
+    AsyncIOBackend,
+    _threadpool_idle_workers,
+    _threadpool_workers,
+    find_root_task,
+)
+from anyio._backends._asyncio import WorkerThread as BaseWorkerThread
+from sniffio import current_async_library_cvar
+
+
+worker_dedicated = ContextVar('worker_dedicated')
+
+
+# BaseWorkerThread_run = BaseWorkerThread.run
+# def run_close_all(self) -> None:
+#     """
+#     We patch the synchronous task thread execution method so that connections are closed at the end of the thread's life,
+#     created in this thread
+#     """
+#     try:
+#         BaseWorkerThread_run(self)
+#     finally:
+#         connections.close_all()
+# BaseWorkerThread.run = run_close_all
+
+
+class IdleWorkersDeque(deque):
+    """
+    A patched double-ended queue that is oriented towards working with run_sync_in_worker_thread
+    Bypasses limitations, allowing work only with a dedicated thread
+    if it exists in the current execution context
+    """
+
+    def pop(self):
+        try:
+            return worker_dedicated.get()
+        except LookupError:
+            return super().pop()
+
+    def __bool__(self):
+        try:
+            return bool(worker_dedicated.get())
+        except LookupError:
+            return bool(len(self))
+
+    def __getitem__(self, *args):
+        try:
+            return worker_dedicated.get()
+        except LookupError:
+            return super().__getitem__(*args)
+
+
+def threadpool_vars_prepare():
+    """
+    Patching environment service variables to enable working with a dedicated thread
+    """
+    try:
+        _threadpool_idle_workers.get()
+        _threadpool_workers.get()
+    except LookupError:
+        _threadpool_idle_workers.set(IdleWorkersDeque())
+        _threadpool_workers.set(set())
+
+
+class ThreadsPool:
+    """
+    Standard behavior of the thread pool
+    """
+
+    async def check(self): ...
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback): ...
+
+
+class DedicatedWorkerThread(BaseWorkerThread):
+    """
+    In this implementation, idle_workers does not receive the current worker after executing a single task.
+    In the native implementation, between tasks, a task from a neighboring context may slip in
+    """
+
+    def __init__(self, *args, **kwargs):
+        pass
+        super().__init__(*args, **kwargs)
+
+    @property
+    def idle_since(self):
+        return AsyncIOBackend.current_time()
+
+    @idle_since.setter
+    def idle_since(self, value):
+        pass
+
+    def _report_result(
+        self, future: asyncio.Future, result: Any, exc: BaseException | None
+    ) -> None:
+        if not future.cancelled():
+            if exc is not None:
+                future.set_exception(exc)
+            else:
+                future.set_result(result)
+
+    def stop(self, f: asyncio.Task | None = None) -> None:
+        self.stopping = True
+        self.queue.put_nowait(None)
+
+
+class ThreadDedicated(ThreadsPool):
+    """
+    FastApi executes synchronous routes inside a thread pool. However, if several synchronous routes need
+    to be executed within a single transaction, then the thread must also be the same.
+    This context manager sets up a custom dedicated thread
+    in the low-level library anyio._backends._asyncio, in the method of which
+    the route is executed: anyio._backends._asyncio.run_sync_in_worker_thread.
+    Thus, the goal of executing all routes in a single transaction is achieved.
+    """
+
+    def __init__(self, using=None):
+        self.atomic = transaction.atomic(using=using)
+        self.worker = None
+        self.worker_token = None
+
+    def _transaction_start(self):
+        self.atomic.__enter__()
+
+    def _transaction_commit(self):
+        self.atomic.__exit__(None, None, None)
+
+    def _transaction_rollback(self, exc_type, exc_value, traceback):
+        self.atomic.__exit__(exc_type, exc_value, traceback)
+
+    def _transaction_clean_rollback(self):
+        if transaction.get_rollback():
+            self.atomic.__exit__(*sys.exc_info())
+            self.atomic.__enter__()
+
+    async def _task_push(self, func, *args):
+        if self.worker:
+            future: asyncio.Future = asyncio.Future()
+            context = copy_context()
+            self.worker.queue.put_nowait((context, func, args, future, None))
+            await future
+
+    async def check(self):
+        await self._task_push(self._transaction_clean_rollback)
+
+    async def __aenter__(self):
+        current_async_library_cvar.set('asyncio')
+
+        workers = _threadpool_workers.get()
+        idle_workers = _threadpool_idle_workers.get()
+
+        root_task = find_root_task()
+        self.worker = DedicatedWorkerThread(root_task, workers, idle_workers)
+        self.worker.start()
+        self.worker_token = worker_dedicated.set(self.worker)
+
+        await self._task_push(self._transaction_start)
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        if exc_type:
+            await self._task_push(self._transaction_rollback, exc_type, exc_value, traceback)
+        else:
+            await self._task_push(self._transaction_commit)
+
+        worker_dedicated.reset(self.worker_token)
+
+        self.worker.stop()

bazis_bulk-2.2.0.dist-info/METADATA

@@ -0,0 +1,825 @@
+Metadata-Version: 2.4
+Name: bazis-bulk
+Version: 2.2.0
+Summary: Bulk operations module for Bazis framework.
+Author-email: Ilya Kharyn <ilya.tt07@gmail.com>
+Maintainer-email: Ilya Kharyn <ilya.tt07@gmail.com>
+Project-URL: Home, https://github.com/ecofuture-tech/bazis-bulk
+Keywords: bazis,django,fastapi,pydantic,framework,jsonapi,bulk
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: Django
+Classifier: Framework :: FastAPI
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: bazis
+Provides-Extra: test
+Requires-Dist: bazis-test-utils; extra == "test"
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+
+# Bazis Bulk
+
+[![PyPI version](https://img.shields.io/pypi/v/bazis-bulk.svg)](https://pypi.org/project/bazis-bulk/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/bazis-bulk.svg)](https://pypi.org/project/bazis-bulk/)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+An extension package for Bazis, providing batch request processing with transaction support and asynchronous execution.
+
+## Quick Start
+
+```bash
+# Install package
+uv add bazis-bulk
+
+# Register route
+# router.py
+from bazis.core.routing import BazisRouter
+
+router = BazisRouter(prefix='/api/v1')
+router.register('bazis.contrib.bulk.router')
+
+# Usage example
+curl -X POST http://localhost/api/v1/bulk/ \
+  -H "Authorization: Bearer YOUR_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '[
+    {
+      "endpoint": "/api/v1/entity/parent_entity/",
+      "method": "POST",
+      "body": {
+        "data": {
+          "type": "entity.parent_entity",
+          "bs:action": "add",
+          "attributes": {"name": "Parent 1"}
+        }
+      }
+    },
+    {
+      "endpoint": "/api/v1/entity/child_entity/",
+      "method": "POST",
+      "body": {
+        "data": {
+          "type": "entity.child_entity",
+          "bs:action": "add",
+          "attributes": {"child_name": "Child 1"}
+        }
+      }
+    }
+  ]'
+```
+
+## Table of Contents
+
+- [Description](#description)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Route Registration](#route-registration)
+  - [Request Format](#request-format)
+  - [Request Parameters](#request-parameters)
+  - [Response Format](#response-format)
+  - [Transactional Mode](#transactional-mode)
+  - [Non-transactional Mode](#non-transactional-mode)
+- [Examples](#examples)
+- [License](#license)
+- [Links](#links)
+
+## Description
+
+**Bazis Bulk** is an extension package for the Bazis framework that allows executing multiple API requests in a single HTTP request. The package includes:
+
+- **Batch request execution** — send multiple operations in one request
+- **Transactional mode** — all operations execute within a single transaction (atomicity)
+- **Non-transactional mode** — operations execute independently
+- **Support for all HTTP methods** — GET, POST, PATCH, PUT, DELETE
+- **JSON:API support** — work with `included` resources and relationships
+- **Dedicated thread for transactions** — guaranteed transaction isolation
+
+**Typical use cases**:
+- Creating related entities in one request
+- Bulk record updates
+- Atomic operations on multiple resources
+- Reducing HTTP request count (lower latency)
+
+**This package requires the base `bazis` package to be installed.**
+
+## Requirements
+
+- **Python**: 3.12+
+- **bazis**: latest version
+- **PostgreSQL**: 12+
+
+## Installation
+
+### Using uv (recommended)
+
+```bash
+uv add bazis-bulk
+```
+
+### Using pip
+
+```bash
+pip install bazis-bulk
+```
+
+## Usage
+
+### Route Registration
+
+Add the route to your main `router.py`:
+
+```python
+from bazis.core.routing import BazisRouter
+
+router = BazisRouter(prefix='/api/v1')
+
+# Register bulk route
+router.register('bazis.contrib.bulk.router')
+```
+
+This creates the endpoint: `POST /api/v1/bulk/`
+
+### Request Format
+
+A bulk request is an array of objects, where each object describes a separate HTTP request.
+
+**Single element structure**:
+
+```typescript
+{
+  "endpoint": string,    // Endpoint path (required)
+  "method": string,      // HTTP method: GET, POST, PATCH, PUT, DELETE (required)
+  "body": object,        // Request body in JSON:API format (optional)
+  "headers": array       // Additional headers (optional, currently ignored)
+}
+```
+
+**Example**:
+
+```json
+[
+  {
+    "endpoint": "/api/v1/entity/parent_entity/",
+    "method": "POST",
+    "body": {
+      "data": {
+        "type": "entity.parent_entity",
+        "bs:action": "add",
+        "attributes": {
+          "name": "New Parent"
+        }
+      }
+    }
+  }
+]
+```
+
+### Request Parameters
+
+#### is_atomic (query parameter)
+
+Defines the request execution mode:
+
+- `is_atomic=true` (default) — **transactional mode**
+  - All operations execute within a single transaction
+  - Any operation error rolls back the entire transaction
+  - Response status: 400 if errors occur
+
+- `is_atomic=false` — **non-transactional mode**
+  - Operations execute independently
+  - Error in one operation doesn't affect others
+  - Response status: 200 even with errors in individual operations
+
+**Examples**:
+
+```bash
+# Transactional mode (default)
+POST /api/v1/bulk/
+POST /api/v1/bulk/?is_atomic=true
+
+# Non-transactional mode
+POST /api/v1/bulk/?is_atomic=false
+```
+
+### Response Format
+
+Each response item contains the original endpoint, HTTP status, headers, and the parsed body.
+
+**Single element structure**:
+
+```typescript
+{
+  "endpoint": string,    // Endpoint path (required)
+  "status": number,      // HTTP status code (required)
+  "headers": array,      // ASGI response headers as [name, value] pairs
+  "response": object     // Parsed JSON for JSON responses, raw body otherwise (may be null)
+}
+```
+
+Headers are returned as emitted by the ASGI app (typically byte pairs).
+
+### Transactional Mode
+
+In transactional mode, all operations execute in a dedicated thread with a single database transaction.
+
+**Features**:
+
+- All operations either succeed completely or rollback entirely
+- Any operation error causes transaction rollback
+- Overall response status: 400 if errors occur
+
+**Request example**:
+
+```bash
+POST /api/v1/bulk/?is_atomic=true
+Content-Type: application/json
+Authorization: Bearer YOUR_TOKEN
+
+[
+  {
+    "endpoint": "/api/v1/orders/order/",
+    "method": "POST",
+    "body": {
+      "data": {
+        "type": "myapp.order",
+        "bs:action": "add",
+        "attributes": {
+          "description": "Order 1",
+          "amount": 1000
+        }
+      }
+    }
+  },
+  {
+    "endpoint": "/api/v1/orders/order/",
+    "method": "POST",
+    "body": {
+      "data": {
+        "type": "myapp.order",
+        "bs:action": "add",
+        "attributes": {
+          "description": "Order 2",
+          "amount": 2000
+        }
+      }
+    }
+  }
+]
+```
+
+**Success response** (status 200):
+
+```json
+[
+  {
+    "endpoint": "/api/v1/orders/order/",
+    "status": 201,
+    "headers": [
+      ["content-type", "application/vnd.api+json"]
+    ],
+    "response": {
+      "data": {
+        "type": "myapp.order",
+        "id": "123e4567-e89b-12d3-a456-426614174000",
+        "attributes": {
+          "description": "Order 1",
+          "amount": 1000
+        }
+      }
+    }
+  },
+  {
+    "endpoint": "/api/v1/orders/order/",
+    "status": 201,
+    "response": {
+      "data": {
+        "type": "myapp.order",
+        "id": "987e6543-e21b-32d1-b654-426614174001",
+        "attributes": {
+          "description": "Order 2",
+          "amount": 2000
+        }
+      }
+    }
+  }
+]
+```
+
+**Error response** (status 400, all operations rolled back):
+
+```json
+[
+  {
+    "endpoint": "/api/v1/orders/order/",
+    "status": 201,
+    "response": {
+      "data": {
+        "type": "myapp.order",
+        "id": "123e4567-e89b-12d3-a456-426614174000",
+        "attributes": {
+          "description": "Order 1"
+        }
+      }
+    }
+  },
+  {
+    "endpoint": "/api/v1/orders/order/",
+    "status": 403,
+    "response": {
+      "errors": [
+        {
+          "status": 403,
+          "detail": "Permission denied"
+        }
+      ]
+    }
+  }
+]
+```
+
+### Non-transactional Mode
+
+In non-transactional mode, each operation executes independently in a thread pool.
+
+**Features**:
+
+- Operations execute independently
+- Error in one operation doesn't affect others
+- Overall response status: always 200
+
+**Request example**:
+
+```bash
+POST /api/v1/bulk/?is_atomic=false
+Content-Type: application/json
+Authorization: Bearer YOUR_TOKEN
+
+[
+  {
+    "endpoint": "/api/v1/orders/order/",
+    "method": "POST",
+    "body": {
+      "data": {
+        "type": "myapp.order",
+        "bs:action": "add",
+        "attributes": {"description": "Order 1"}
+      }
+    }
+  },
+  {
+    "endpoint": "/api/v1/orders/order/999/",
+    "method": "DELETE",
+    "body": {}
+  }
+]
+```
+
+**Response** (status 200, even with errors):
+
+```json
+[
+  {
+    "endpoint": "/api/v1/orders/order/",
+    "status": 201,
+    "response": {
+      "data": {
+        "type": "myapp.order",
+        "id": "123e4567-e89b-12d3-a456-426614174000"
+      }
+    }
+  },
+  {
+    "endpoint": "/api/v1/orders/order/999/",
+    "status": 404,
+    "response": {
+      "errors": [
+        {
+          "status": 404,
+          "detail": "Not found"
+        }
+      ]
+    }
+  }
+]
+```
+
+## Examples
+
+### Example 1: Creating Related Entities
+
+Creating a parent entity and two child entities in one transaction:
+
+```json
+[
+  {
+    "endpoint": "/api/v1/entity/parent_entity/",
+    "method": "POST",
+    "body": {
+      "data": {
+        "type": "entity.parent_entity",
+        "bs:action": "add",
+        "attributes": {
+          "name": "Parent Entity"
+        }
+      }
+    }
+  },
+  {
+    "endpoint": "/api/v1/entity/child_entity/",
+    "method": "POST",
+    "body": {
+      "data": {
+        "type": "entity.child_entity",
+        "bs:action": "add",
+        "attributes": {
+          "child_name": "Child 1"
+        }
+      }
+    }
+  },
+  {
+    "endpoint": "/api/v1/entity/child_entity/",
+    "method": "POST",
+    "body": {
+      "data": {
+        "type": "entity.child_entity",
+        "bs:action": "add",
+        "attributes": {
+          "child_name": "Child 2"
+        }
+      }
+    }
+  }
+]
+```
+
+### Example 2: Update with Included Resources
+
+Updating a parent entity and its related children:
+
+```json
+[
+  {
+    "endpoint": "/api/v1/entity/parent_entity/123/?include=extended_entity,dependent_entities",
+    "method": "PATCH",
+    "body": {
+      "data": {
+        "id": "123",
+        "type": "entity.parent_entity",
+        "bs:action": "change",
+        "attributes": {
+          "name": "Updated Parent"
+        }
+      },
+      "included": [
+        {
+          "id": "456",
+          "type": "entity.extended_entity",
+          "bs:action": "change",
+          "attributes": {
+            "extended_name": "Updated Extended"
+          }
+        },
+        {
+          "type": "entity.dependent_entity",
+          "bs:action": "add",
+          "attributes": {
+            "dependent_name": "New Dependent"
+          },
+          "relationships": {
+            "parent_entity": {
+              "data": {
+                "id": "123",
+                "type": "entity.parent_entity"
+              }
+            }
+          }
+        }
+      ]
+    }
+  }
+]
+```
+
+### Example 3: Bulk Update
+
+Updating multiple records simultaneously:
+
+```json
+[
+  {
+    "endpoint": "/api/v1/entity/child_entity/child-1/",
+    "method": "PATCH",
+    "body": {
+      "data": {
+        "id": "child-1",
+        "type": "entity.child_entity",
+        "bs:action": "change",
+        "attributes": {
+          "child_name": "Updated Child 1"
+        }
+      }
+    }
+  },
+  {
+    "endpoint": "/api/v1/entity/child_entity/child-2/",
+    "method": "PATCH",
+    "body": {
+      "data": {
+        "id": "child-2",
+        "type": "entity.child_entity",
+        "bs:action": "change",
+        "attributes": {
+          "child_name": "Updated Child 2"
+        }
+      }
+    }
+  },
+  {
+    "endpoint": "/api/v1/entity/child_entity/child-3/",
+    "method": "PATCH",
+    "body": {
+      "data": {
+        "id": "child-3",
+        "type": "entity.child_entity",
+        "bs:action": "change",
+        "attributes": {
+          "child_name": "Updated Child 3"
+        }
+      }
+    }
+  }
+]
+```
+
+### Example 4: Mixed Operations
+
+Create, update, and delete in one request:
+
+```json
+[
+  {
+    "endpoint": "/api/v1/entity/parent_entity/",
+    "method": "POST",
+    "body": {
+      "data": {
+        "type": "entity.parent_entity",
+        "bs:action": "add",
+        "attributes": {"name": "New Parent"}
+      }
+    }
+  },
+  {
+    "endpoint": "/api/v1/entity/parent_entity/existing-id/",
+    "method": "PATCH",
+    "body": {
+      "data": {
+        "id": "existing-id",
+        "type": "entity.parent_entity",
+        "bs:action": "change",
+        "attributes": {"price": "845.42"}
+      }
+    }
+  },
+  {
+    "endpoint": "/api/v1/entity/child_entity/old-id/",
+    "method": "DELETE",
+    "body": {}
+  }
+]
+```
+
+### Example 5: JavaScript Client
+
+```javascript
+class BulkClient {
+  constructor(apiUrl, token) {
+    this.apiUrl = apiUrl;
+    this.token = token;
+  }
+
+  async executeBulk(operations, isAtomic = true) {
+    const url = `${this.apiUrl}/bulk/?is_atomic=${isAtomic}`;
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.token}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(operations)
+    });
+
+    if (!response.ok) {
+      throw new Error(`Bulk request failed: ${response.status}`);
+    }
+
+    return await response.json();
+  }
+
+  async createMultiple(entities, isAtomic = true) {
+    const operations = entities.map(entity => ({
+      endpoint: entity.endpoint,
+      method: 'POST',
+      body: {
+        data: {
+          type: entity.type,
+          'bs:action': 'add',
+          attributes: entity.attributes,
+          relationships: entity.relationships
+        }
+      }
+    }));
+
+    return await this.executeBulk(operations, isAtomic);
+  }
+
+  async updateMultiple(updates, isAtomic = true) {
+    const operations = updates.map(update => ({
+      endpoint: `${update.endpoint}/${update.id}/`,
+      method: 'PATCH',
+      body: {
+        data: {
+          id: update.id,
+          type: update.type,
+          'bs:action': 'change',
+          attributes: update.attributes
+        }
+      }
+    }));
+
+    return await this.executeBulk(operations, isAtomic);
+  }
+}
+
+// Usage
+const bulk = new BulkClient('http://api.example.com/api/v1', jwtToken);
+
+// Create multiple entities atomically
+const results = await bulk.createMultiple([
+  {
+    endpoint: '/api/v1/orders/order',
+    type: 'myapp.order',
+    attributes: { description: 'Order 1', amount: 1000 }
+  },
+  {
+    endpoint: '/api/v1/orders/order',
+    type: 'myapp.order',
+    attributes: { description: 'Order 2', amount: 2000 }
+  }
+], true);
+
+console.log('Created:', results);
+
+// Bulk update without transaction
+await bulk.updateMultiple([
+  {
+    endpoint: '/api/v1/orders/order',
+    id: 'order-1',
+    type: 'myapp.order',
+    attributes: { status: 'completed' }
+  },
+  {
+    endpoint: '/api/v1/orders/order',
+    id: 'order-2',
+    type: 'myapp.order',
+    attributes: { status: 'completed' }
+  }
+], false);
+```
+
+### Example 6: Python Client
+
+```python
+import requests
+from typing import List, Dict, Any
+
+class BulkClient:
+    def __init__(self, api_url: str, token: str):
+        self.api_url = api_url
+        self.token = token
+        self.headers = {
+            'Authorization': f'Bearer {token}',
+            'Content-Type': 'application/json'
+        }
+
+    def execute_bulk(
+        self,
+        operations: List[Dict[str, Any]],
+        is_atomic: bool = True
+    ) -> List[Dict[str, Any]]:
+        """Execute bulk request"""
+        url = f"{self.api_url}/bulk/?is_atomic={str(is_atomic).lower()}"
+
+        response = requests.post(
+            url,
+            headers=self.headers,
+            json=operations
+        )
+        response.raise_for_status()
+
+        return response.json()
+
+    def create_with_related(
+        self,
+        parent_data: Dict[str, Any],
+        children_data: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        """Create parent entity with children in one transaction"""
+        operations = [
+            {
+                'endpoint': parent_data['endpoint'],
+                'method': 'POST',
+                'body': {
+                    'data': {
+                        'type': parent_data['type'],
+                        'bs:action': 'add',
+                        'attributes': parent_data['attributes']
+                    }
+                }
+            }
+        ]
+
+        for child in children_data:
+            operations.append({
+                'endpoint': child['endpoint'],
+                'method': 'POST',
+                'body': {
+                    'data': {
+                        'type': child['type'],
+                        'bs:action': 'add',
+                        'attributes': child['attributes'],
+                        'relationships': child.get('relationships', {})
+                    }
+                }
+            })
+
+        return self.execute_bulk(operations, is_atomic=True)
+
+# Usage
+bulk = BulkClient('http://api.example.com/api/v1', jwt_token)
+
+# Create order with items
+results = bulk.create_with_related(
+    parent_data={
+        'endpoint': '/api/v1/orders/order',
+        'type': 'myapp.order',
+        'attributes': {
+            'description': 'New Order',
+            'customer': 'John Doe'
+        }
+    },
+    children_data=[
+        {
+            'endpoint': '/api/v1/orders/orderitem',
+            'type': 'myapp.orderitem',
+            'attributes': {
+                'product': 'Product 1',
+                'quantity': 2,
+                'price': '100.00'
+            }
+        },
+        {
+            'endpoint': '/api/v1/orders/orderitem',
+            'type': 'myapp.orderitem',
+            'attributes': {
+                'product': 'Product 2',
+                'quantity': 1,
+                'price': '50.00'
+            }
+        }
+    ]
+)
+
+print(f"Created order with {len(results) - 1} items")
+```
+
+## License
+
+Apache License 2.0
+
+See [LICENSE](LICENSE) file for details.
+
+## Links
+
+- [Bazis Documentation](https://github.com/ecofuture-tech/bazis) — main repository
+- [Bazis Bulk Repository](https://github.com/ecofuture-tech/bazis-bulk) — package repository
+- [Issue Tracker](https://github.com/ecofuture-tech/bazis-bulk/issues) — report bugs or request features
+
+## Support
+
+If you have questions or issues:
+- Review the [Bazis documentation](https://github.com/ecofuture-tech/bazis)
+- Search through [existing issues](https://github.com/ecofuture-tech/bazis-bulk/issues)
+- Create a [new issue](https://github.com/ecofuture-tech/bazis-bulk/issues/new) with detailed information
+
+---
+
+Made with ❤️ by the Bazis team

bazis_bulk-2.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+bazis/contrib/bulk/__init__.py,sha256=iaqxVnQxmpxbVMx2W-eBDvI_04GlA13Ojda5Swdio7g,778
+bazis/contrib/bulk/_version.py,sha256=6OGz4a0gjMGlckPyPCNiJDWyFDO-tWO8O_ZNx4ajT2Y,704
+bazis/contrib/bulk/router.py,sha256=M9ksiD9bi25TCnRjukq2I91_nbWJlaLzvaazQz7wO5w,1138
+bazis/contrib/bulk/routes.py,sha256=ueeE6HiTHokDsnWrYl2D70dSVQy8-eb3WTRWlowUyMY,4437
+bazis/contrib/bulk/schemas.py,sha256=6YaAwyRP4y8t-uqRqace_la9pxgb6dQak4EEFPT3C2Y,976
+bazis/contrib/bulk/utils.py,sha256=zKCGQA-ptQyk4diy2GrarbxiPRwoUeYEQcvXPhuA5aY,5985
+bazis/contrib/bulk/locale/en/LC_MESSAGES/django.mo,sha256=N1pb17IfLd0ASiKO8d68-B4ygSpDkhKOCs8YTzMXQo0,380
+bazis/contrib/bulk/locale/en/LC_MESSAGES/django.po,sha256=bQnd0ts6l9WguZkGDd-iwum40cTAo67DvPK9wqqSyNw,676
+bazis/contrib/bulk/locale/ru/LC_MESSAGES/django.mo,sha256=sd5jWcMlx4L-UqS82VO2cYKmKhrvDiSFuYXzAWt8lGg,588
+bazis/contrib/bulk/locale/ru/LC_MESSAGES/django.po,sha256=b1XEGpECiweGTKtluO1x4Oo9k3GqJ1WcKpsjXTMP9Oc,851
+bazis_bulk-2.2.0.dist-info/METADATA,sha256=qBdZ4uOZJlj3JrHbtJMqSHFnNAXp9LuBGKUlJUsN6S0,19162
+bazis_bulk-2.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+bazis_bulk-2.2.0.dist-info/top_level.txt,sha256=WgdrPZTZBMG8i_EqxA3vU5qI4ETQ_RsqKqSqsfIApHY,6
+bazis_bulk-2.2.0.dist-info/RECORD,,

bazis_bulk-2.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bazis_bulk-2.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bazis