aisberg 0.1.0__py3-none-any.whl

aisberg/modules/workflows.py

@@ -0,0 +1,140 @@
+from typing import List, Union, Generator, AsyncGenerator, Coroutine, Any
+from abc import ABC
+
+from ..models.workflows import (
+    Workflow,
+    WorkflowDetails,
+    WorkflowRunChunk,
+    WorkflowRunResult,
+)
+
+from abc import abstractmethod
+from ..abstract.modules import SyncModule, AsyncModule
+from ..api import endpoints, async_endpoints
+
+
+class AbstractWorkflowsModule(ABC):
+    def __init__(self, parent, client):
+        self._parent = parent
+        self._client = client
+
+    @abstractmethod
+    def get(self) -> List[Workflow]:
+        """Get a list of available workflows.
+
+        Returns:
+            List[dict]: A list of available workflows.
+
+        Raises:
+            Exception: If there is an error fetching the workflows.
+        """
+        pass
+
+    @abstractmethod
+    def details(self, workflow_id: str) -> WorkflowDetails:
+        """Get details of a specific workflow.
+
+        Args:
+            workflow_id (str): The ID of the workflow to retrieve.
+
+        Returns:
+            WorkflowDetails: The details of the specified workflow.
+
+        Raises:
+            ValueError: If the workflow with the specified ID is not found.
+            Exception: If there is an error fetching the workflow details.
+        """
+        pass
+
+    @abstractmethod
+    def run(self, workflow_id: str, data: dict = None, stream: bool = False):
+        """
+        Run a workflow with the given ID and data.
+        If `stream` is True, it will yield chunks of the workflow run.
+        If `stream` is False, it will return the final result of the workflow run.
+
+        Args:
+            workflow_id (str): The ID of the workflow to run.
+            data (dict, optional): The input data for the workflow. Defaults to None.
+            stream (bool, optional): If True, returns a generator yielding chunks of the workflow run. Defaults to False.
+
+        Returns:
+            Union[Generator[WorkflowRunChunk, None, None], WorkflowRunResult]:
+                If `stream` is True, a generator yielding chunks of the workflow run.
+                If `stream` is False, the final result of the workflow run.
+
+        Raises:
+            ValueError: If the workflow with the specified ID is not found.
+            Exception: If there is an error running the workflow.
+        """
+        pass
+
+
+class SyncWorkflowsModule(SyncModule, AbstractWorkflowsModule):
+    def __init__(self, parent, client):
+        SyncModule.__init__(self, parent, client)
+        AbstractWorkflowsModule.__init__(self, parent, client)
+
+    def get(self) -> List[Workflow]:
+        return endpoints.workflows(self._client)
+
+    def details(self, workflow_id: str) -> WorkflowDetails:
+        return endpoints.workflow(self._client, workflow_id)
+
+    def run(
+        self, workflow_id: str, data: dict = None, stream: bool = False
+    ) -> Union[Generator[WorkflowRunChunk, None, None], WorkflowRunResult]:
+        if stream:
+            return self._run_stream(workflow_id, data)
+        else:
+            return self._run_once(workflow_id, data)
+
+    def _run_stream(
+        self, workflow_id: str, data: dict = None
+    ) -> Generator[WorkflowRunChunk, None, None]:
+        for chunk in endpoints.run_workflow(self._client, workflow_id, data):
+            yield WorkflowRunChunk.model_validate(chunk)
+
+    def _run_once(self, workflow_id: str, data: dict = None) -> WorkflowRunResult:
+        last_response = None
+        for chunk in endpoints.run_workflow(self._client, workflow_id, data):
+            last_response = chunk
+        return WorkflowRunResult.model_validate(last_response)
+
+
+class AsyncWorkflowsModule(AsyncModule, AbstractWorkflowsModule):
+    def __init__(self, parent, client):
+        AsyncModule.__init__(self, parent, client)
+        AbstractWorkflowsModule.__init__(self, parent, client)
+
+    async def get(self) -> List[Workflow]:
+        return await async_endpoints.workflows(self._client)
+
+    async def details(self, workflow_id: str) -> WorkflowDetails:
+        return await async_endpoints.workflow(self._client, workflow_id)
+
+    def run(
+        self, workflow_id: str, data: dict = None, stream: bool = False
+    ) -> Union[
+        AsyncGenerator[WorkflowRunChunk, None], Coroutine[Any, Any, WorkflowRunResult]
+    ]:
+        if stream:
+            return self._run_stream(workflow_id, data)
+        else:
+            return self._run_once(workflow_id, data)
+
+    async def _run_stream(
+        self, workflow_id: str, data: dict = None
+    ) -> AsyncGenerator[WorkflowRunChunk, None]:
+        async for chunk in async_endpoints.run_workflow(
+            self._client, workflow_id, data
+        ):
+            yield WorkflowRunChunk.model_validate(chunk)
+
+    async def _run_once(self, workflow_id: str, data: dict = None) -> WorkflowRunResult:
+        last_response = None
+        async for chunk in async_endpoints.run_workflow(
+            self._client, workflow_id, data
+        ):
+            last_response = chunk
+        return WorkflowRunResult.model_validate(last_response)

aisberg/requests/async_requests.py

@@ -0,0 +1,85 @@
+from typing import Type, TypeVar, Any, Dict, Optional, Callable
+import httpx
+from pydantic import ValidationError, BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+
+async def areq(
+    client: httpx.AsyncClient,
+    method: str,
+    url: str,
+    response_model: Type[T],
+    *,
+    expected_status: int = 200,
+    handle_404_none: bool = False,
+    **kwargs,
+) -> Optional[T]:
+    """
+    Send an HTTP request asynchronously, parse the response.
+    Return None if 404 and handle_404_none=True, else raise.
+    """
+    try:
+        resp = await client.request(method, url, **kwargs)
+        if handle_404_none and resp.status_code == 404:
+            return None
+
+        if 400 <= resp.status_code < 500:
+            resp.read()
+            if resp.text == "Please specify a group":
+                raise httpx.HTTPStatusError(
+                    "Bad Request: Please specify a group. Use `AisbergClient.me.groups()` to know which groups you are in.",
+                    request=resp.request,
+                    response=resp,
+                )
+            raise httpx.HTTPStatusError(
+                f"Bad Request: {resp.text}", request=resp.request, response=resp
+            )
+
+        resp.raise_for_status()
+        return response_model.model_validate(resp.json())
+    except httpx.HTTPStatusError as e:
+        if handle_404_none and e.response.status_code == 404:
+            return None
+        raise
+    except ValidationError as ve:
+        raise RuntimeError(f"Invalid response: {ve}") from ve
+
+
+async def areq_stream(
+    client: httpx.AsyncClient,
+    method: str,
+    url: str,
+    parse_line: Callable[[str], Any],
+    *,
+    handle_status: Optional[Dict[int, Any]] = None,
+    **kwargs,
+) -> Any:
+    """
+    Wrapper to handle HTTP streams.
+    - parse_line: Function to parse each line of the stream.
+    """
+    async with client.stream(method, url, **kwargs) as resp:
+        if handle_status and resp.status_code in handle_status:
+            yield handle_status[resp.status_code]
+            return
+
+        if 400 <= resp.status_code < 500:
+            resp.read()
+            if resp.text == "Please specify a group":
+                raise httpx.HTTPStatusError(
+                    "Bad Request: Please specify a group. Use `await AisbergAsyncClient.me.groups()` to know which groups you are in.",
+                    request=resp.request,
+                    response=resp,
+                )
+            raise httpx.HTTPStatusError(
+                f"Bad Request: {resp.text}", request=resp.request, response=resp
+            )
+
+        resp.raise_for_status()
+        async for raw_line in resp.aiter_lines():
+            if not raw_line:
+                continue
+            line = raw_line.decode() if isinstance(raw_line, bytes) else raw_line
+            for parsed in parse_line(line):
+                yield parsed

aisberg/requests/sync_requests.py

@@ -0,0 +1,85 @@
+from typing import Type, TypeVar, Any, Dict, Optional, Generator, Callable
+import httpx
+from pydantic import BaseModel, ValidationError
+
+T = TypeVar("T", bound=BaseModel)
+
+
+def req(
+    client: httpx.Client,
+    method: str,
+    url: str,
+    response_model: Type[T],
+    *,
+    expected_status: int = 200,
+    handle_404_none: bool = False,
+    **kwargs,
+) -> Optional[T]:
+    """
+    Send an HTTP request synchronously, parse the response.
+    Return None if 404 and handle_404_none=True, else raise.
+    """
+    try:
+        resp = client.request(method, url, **kwargs)
+        if handle_404_none and resp.status_code == 404:
+            return None
+
+        if 400 <= resp.status_code < 500:
+            resp.read()
+            if resp.text == "Please specify a group":
+                raise httpx.HTTPStatusError(
+                    "Bad Request: Please specify a group. Use `AisbergClient.me.groups()` to know which groups you are in.",
+                    request=resp.request,
+                    response=resp,
+                )
+            raise httpx.HTTPStatusError(
+                f"Bad Request: {resp.text}", request=resp.request, response=resp
+            )
+
+        resp.raise_for_status()
+        return response_model.model_validate(resp.json())
+    except httpx.HTTPStatusError as e:
+        if handle_404_none and e.response.status_code == 404:
+            return None
+        raise
+    except ValidationError as ve:
+        raise RuntimeError(f"Invalid response: {ve}") from ve
+
+
+def req_stream(
+    client: httpx.Client,
+    method: str,
+    url: str,
+    parse_line: Callable[[str], Any],
+    *,
+    handle_status: Optional[Dict[int, Any]] = None,
+    **kwargs,
+) -> Generator[Any, None, None]:
+    """
+    Wrapper to handle HTTP streams.
+    - parse_line: Function to parse each line of the stream.
+    """
+    with client.stream(method, url, **kwargs) as resp:
+        if handle_status and resp.status_code in handle_status:
+            yield handle_status[resp.status_code]
+            return
+
+        if 400 <= resp.status_code < 500:
+            resp.read()
+            if resp.text == "Please specify a group":
+                raise httpx.HTTPStatusError(
+                    "Bad Request: Please specify a group. Use `await AisbergAsyncClient.me.groups()` to know which groups you are in.",
+                    request=resp.request,
+                    response=resp,
+                )
+            raise httpx.HTTPStatusError(
+                f"Bad Request: {resp.text}", request=resp.request, response=resp
+            )
+
+        resp.raise_for_status()
+        for raw_line in resp.iter_lines():
+            if not raw_line:
+                continue
+            line = raw_line.decode() if isinstance(raw_line, bytes) else raw_line
+            for parsed in parse_line(line):
+                yield parsed

aisberg/utils.py

@@ -0,0 +1,111 @@
+from typing import Iterator, Union, Dict
+import json
+
+
+def parse_chat_line(
+    line: str, *, full_chunk: bool = True
+) -> Iterator[Union[str, dict]]:
+    """
+    Parse une ligne de stream JSON (commençant par `data:`) et yield un ou plusieurs éléments utilisables.
+
+    Args:
+        line (str): Ligne du flux à traiter.
+        full_chunk (bool): Contrôle le format de sortie (chunk brut ou contenu transformé).
+
+    Yields:
+        Union[str, dict]: Le chunk complet ou un morceau de texte/fonction/tool_call.
+    """
+    if not line.startswith("data:"):
+        return
+
+    data = line[len("data:") :].strip()
+    if data == "[DONE]":
+        return
+
+    try:
+        chunk: dict = json.loads(data)
+
+        if chunk["object"] != "chat.completion.chunk":
+            raise ValueError(f"Unexpected object type: {chunk['object']}")
+
+        if chunk["choices"][0]["finish_reason"] == "stop":
+            return
+
+        if full_chunk:
+            yield chunk
+            return
+
+        delta = chunk.get("choices", [{}])[0].get("delta", {})
+
+        if "content" in delta and delta["content"]:
+            yield delta["content"]
+
+        elif "function_call" in delta and delta["function_call"]:
+            yield f"[FUNCTION_CALL]{delta['function_call']}"
+
+        elif "tool_calls" in delta and delta["tool_calls"]:
+            yield f"[TOOL_CALLS]{delta['tool_calls']}"
+
+    except json.JSONDecodeError:
+        return
+
+
+class WorkflowLineParser:
+    def __init__(self, full_chunk: bool = True):
+        self.full_chunk = full_chunk
+        self._buckets: Dict[str, Dict] = {}
+
+    def __call__(self, line: str) -> Iterator[Union[str, dict]]:
+        if not line.startswith("data:"):
+            return
+        data = line[len("data:") :].strip()
+        if data == "[DONE]":
+            return
+
+        try:
+            payload = json.loads(data)
+
+            # Gestion des events chunk + slices
+            if payload.get("type") == "chunk":
+                self._buckets[payload["id"]] = {
+                    "totalSlices": payload["totalSlices"],
+                    "slices": [None] * payload["totalSlices"],
+                }
+
+            elif payload.get("type") == "chunk_slice":
+                bucket = self._buckets.get(payload["id"])
+                if bucket:
+                    bucket["slices"][payload["index"]] = payload["slice"]
+
+            elif payload.get("type") == "chunk_end":
+                bucket = self._buckets.pop(payload["id"], None)
+                if bucket:
+                    full_json = "".join(bucket["slices"])
+                    try:
+                        yield from self._yield_chunk(full_json)
+                    except json.JSONDecodeError:
+                        return
+
+            else:
+                # Message "normal" non splitté
+                yield from self._yield_chunk(data)
+
+        except json.JSONDecodeError:
+            return
+
+    def _yield_chunk(self, raw: str) -> Iterator[Union[str, dict]]:
+        chunk = json.loads(raw)
+
+        if "slice" in chunk:
+            try:
+                if isinstance(chunk["slice"], str):
+                    # Si la slice est déjà un JSON string, on la parse
+                    parsed_slice = json.loads(chunk["slice"])
+                    yield parsed_slice
+                elif isinstance(chunk["slice"], dict):
+                    # Si la slice est déjà un dict, on la yield directement
+                    yield chunk["slice"]
+            except json.JSONDecodeError:
+                return
+        else:
+            return

aisberg-0.1.0.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.4
+Name: aisberg
+Version: 0.1.0
+Summary: Aisberg SDK for Python - A simple and powerful SDK to interact with the Aisberg API
+Author: Free Pro
+Author-email: Mathis Lambert <mathis.lambert@freepro.com>
+License: Private License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: License :: Other/Proprietary License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pydantic-settings>=2.10.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.4.1; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=6.2.1; extra == "dev"
+Requires-Dist: pytest-mock>=3.14.1; extra == "dev"
+Requires-Dist: black>=25.1.0; extra == "dev"
+Requires-Dist: isort>=6.0.1; extra == "dev"
+Requires-Dist: mypy>=1.16.1; extra == "dev"
+Requires-Dist: flake8>=7.3.0; extra == "dev"
+Dynamic: license-file
+
+# Aisberg Python SDK
+
+![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)
+![License](https://img.shields.io/badge/license-Private-informational)
+
+Aisberg SDK for Python is a robust and easy-to-use library for interacting with the Aisberg API.  
+It provides **synchronous** and **asynchronous** clients, advanced module abstractions, and built-in support for
+conversational LLM workflows, collections, embeddings, and more.
+
+---
+
+## Features
+
+- **Sync & Async clients**: Use with regular scripts or async frameworks
+- **Auto tool execution** for LLM flows (tool calls, results integration)
+- **Modular architecture**: Collections, chat, models, workflows, embeddings, and more
+- **Strong typing** via Pydantic models
+- **Environment-based configuration** (supports `.env` files and system environment variables)
+- **Context manager support** for easy resource management
+- **Custom tool registration**: Easily extend LLM capabilities with your own functions
+
+---
+
+## Installation
+
+```sh
+pip install aisberg
+````
+
+Or, for local development:
+
+```sh
+git clone https://your.git.repo/aisberg.git
+cd aisberg
+pip install -e .
+```
+
+---
+
+## Quickstart
+
+### 1. **Configure your API key and base URL**
+
+You can set them as environment variables, or in a `.env` file:
+
+```env
+AISBERG_API_KEY=...
+AISBERG_BASE_URL=https://url
+```
+
+### 2. **Synchronous Usage**
+
+```python
+from aisberg import AisbergClient
+
+with AisbergClient() as client:
+    me = client.me.info()
+    print(me)
+
+    chat_response = client.chat.complete(
+        input="Bonjour, qui es-tu ?",
+        model="llm-aisberg",
+    )
+    print(chat_response.choices[0].message.content)
+```
+
+### 3. **Asynchronous Usage**
+
+```python
+import asyncio
+from aisberg import AisbergAsyncClient
+
+
+async def main():
+    async with AisbergAsyncClient() as client:
+        await client.initialize()
+        me = await client.me.info()
+        print(me)
+
+        chat_response = await client.chat.complete(
+            input="Hello, who are you?",
+            model="llm-aisberg",
+        )
+        print(chat_response.choices[0].message.content)
+
+
+asyncio.run(main())
+```
+
+---
+
+## Modules
+
+* `client.me` — User/account info
+* `client.chat` — Conversational LLM completions and streaming
+* `client.collections` — Manage data collections
+* `client.embeddings` — Encode texts to embeddings
+* `client.models` — Model discovery & info
+* `client.workflows` — Workflow management & execution
+* `client.tools` — Register and execute tools for LLM tool calls
+
+Each module is available both in the sync and async clients with similar APIs.
+
+---
+
+## Tool Calls and Automatic Execution
+
+The SDK supports **tool-augmented LLM workflows**.
+Register your own functions for use in chat:
+
+```python
+def my_tool(args):
+    # Custom business logic
+    return {"result": "tool output"}
+
+
+client.tools.register("my_tool", my_tool)
+response = client.chat.complete(
+    input="Use the tool please.",
+    model="llm-aisberg",
+    tools=[{"name": "my_tool", ...}],
+    auto_execute_tools=True,
+)
+```
+
+---
+
+## Advanced Usage
+
+### **Custom Configuration**
+
+You can override configuration when instantiating the client:
+
+```python
+client = AisbergClient(
+    api_key="...",
+    base_url="https://url",
+    timeout=60,
+)
+```
+
+### **Environment Variables Supported**
+
+* `AISBERG_API_KEY`
+* `AISBERG_BASE_URL`
+* `AISBERG_TIMEOUT` (optional)
+
+### **Using in a Context Manager**
+
+Both clients are context manager compatible:
+
+```python
+with AisbergClient() as client:
+    # Sync usage
+    ...
+
+async with AisbergAsyncClient() as client:
+    # Async usage
+    ...
+```
+
+---
+
+## License
+
+**Private License — Not for public distribution or resale.**
+
+For enterprise/commercial use, please contact [Mathis Lambert](mailto:mathis.lambert@freepro.com) or Free Pro.
+
+---
+
+## Authors
+
+* Mathis Lambert
+* Free Pro
+
+---
+
+## Support
+
+For support, bug reports, or feature requests, please contact your technical representative.
+
+---

aisberg-0.1.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+aisberg/__init__.py,sha256=jMX3F2Fh5JobAkRMKGAcOpmNdoxSthgR4v_oM-Yw1l0,141
+aisberg/async_client.py,sha256=wxwkRUjxFbBlcj3D0aFspCVX5aACCksVhG9ZPVYrtx4,3547
+aisberg/client.py,sha256=-UgM9pi-R_qeUmods8sWTxBVGM13pNUfLJv8Zq1vQto,3586
+aisberg/config.py,sha256=tYuaE8WQFyyGhXEgF3kKLX7wM4PDIv6vDoezXaryOhk,441
+aisberg/exceptions.py,sha256=T1ioitOczdkmW3-8XfPG0ta_O2WqzS1iQtzhDBucb5Y,515
+aisberg/utils.py,sha256=4wkrpC5gz8PJWw3kZqaRbd3KekrI37zlDC__JiAVitw,3552
+aisberg/abstract/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aisberg/abstract/modules.py,sha256=aRmB21oiL9NCZsHUx8zB0Q8VvZAZBucsZxYv5l7JygY,1698
+aisberg/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aisberg/api/async_endpoints.py,sha256=cYOmUGBnMrvj8zaiek_Cjut6tB3paEIlJRHjRbggQBc,8279
+aisberg/api/endpoints.py,sha256=Ni-boFbHpB4ZiCbBwLCzoy8bxRTie-LHmBddqbwVn7Q,8003
+aisberg/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aisberg/models/chat.py,sha256=LcvOgQm9Aan7pS4S90h4lrdzENX-NebA9pAKYdcDLB8,3667
+aisberg/models/collections.py,sha256=gtcpyMfUVkfZkWP82AlsfNDT0mM_wREdjnR32i3DP20,806
+aisberg/models/embeddings.py,sha256=gBGXR3DgyBCWB9Vky-iowWh_2Md7wa57I3fWxIrl77I,2409
+aisberg/models/models.py,sha256=NcECFpeVjt9nzQEN8lggDy-SesDSDFgSAYhqWz0dupA,1206
+aisberg/models/requests.py,sha256=9QXt9COo3GfubLQR5AgajxaDEr-ZOHrdjp-j9nyZrlw,205
+aisberg/models/token.py,sha256=p3-uxCZMHbe4yryQdH21iDnPh-etJWgvUDUpCXV2xhk,190
+aisberg/models/tools.py,sha256=dO8-O-tV9usakviEvWzT7Z-dG5s7EkVV8cg5CyoxZHg,1830
+aisberg/models/workflows.py,sha256=CiqJdHsSFrOo2DAYNvYFvFOmO0hyg0xUehktkn3maSg,1258
+aisberg/modules/__init__.py,sha256=i499QPWq-JB596dRVuBFNleYoldJshYXGmC4oed0f58,725
+aisberg/modules/chat.py,sha256=WrMvq0O5gdBggoGm_dJcJywsHJvlKKYBUQ5HgPipQuU,13822
+aisberg/modules/collections.py,sha256=kgV7zFHme6d2SXPKITJknxnk1yc6SoWz2LGnGoifon0,3947
+aisberg/modules/document.py,sha256=twloRFq1wRS4j6fzth77IdceAaSrdDULzu3hlTiIsrA,3902
+aisberg/modules/embeddings.py,sha256=wq7DlOXVQBP9-V5f4ytY4nnD60DAJ49v6JFlBuJwmEs,10470
+aisberg/modules/me.py,sha256=yN4-ZYVDLViwz1oXbDpF1_1gULWiBf5GL0wj9-Pp-H4,2145
+aisberg/modules/models.py,sha256=EIyWOkO2FaOYV-fNB-42-AEY2bob6yA1_4bqlwKs6JY,3048
+aisberg/modules/tools.py,sha256=TnTIfjQuPhPImtWTjEy3UCmXeroPrYX3BRzTvT9nIkk,2424
+aisberg/modules/workflows.py,sha256=TGDriJYy__dRBwP-MK-8zl6mlzZs22-0_TUqYYTeVfs,5004
+aisberg/requests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aisberg/requests/async_requests.py,sha256=4J6Gj6vY5AD9lXhSTdYdAKQIqsqH9m1uaKc7XLDKWx8,2849
+aisberg/requests/sync_requests.py,sha256=ov7GDgx4C-oQ9xEZ7VQsGVY1fnuqRpPwjS0H_yH1yb8,2839
+aisberg-0.1.0.dist-info/licenses/LICENSE,sha256=dCGgiGa4f14s5mzTYnj1wIZNqGRVG2bUYyyk7nzKlEo,406
+tests/integration/test_collections_integration.py,sha256=HSs-Mhh5JNx2V6EeKo--G3xZq7pMk3z3gLReX7FJidg,3883
+tests/unit/test_collections_sync.py,sha256=DyizG4MIYNtBOC9TlsFdLlH5vz7USA12K9Uydlcydoo,3199
+tmp/test.py,sha256=8H3GxLztspwyt3_wLPtQkwdiLl--qqAn8ZaEUsXbwDE,743
+tmp/test_async.py,sha256=BaY3MkOIDXsersjYgnfaI43kZ42KDj5Andq5u-yO82s,4168
+tmp/test_doc_parse.py,sha256=b41Tsa1VkgNwyKwKoDRLNd05sIFGVaJncJGlFGiwYWY,324
+tmp/test_sync.py,sha256=87QSz728gvjTXz2JykjF0U_mNsunDYrWsXYDjkBybI8,4929
+aisberg-0.1.0.dist-info/METADATA,sha256=ETmG5wRMX4W_Xr_L8ZyAXyS2BgtQcOLiIIE03vYEatA,5053
+aisberg-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aisberg-0.1.0.dist-info/top_level.txt,sha256=7_CasmLkyF_h1CVRncNuAjam-DMIeMu1Rev_LpVcWoA,18
+aisberg-0.1.0.dist-info/RECORD,,

aisberg-0.1.0.dist-info/WHEEL

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

aisberg-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,9 @@
+Copyright © 2025 Free Pro. All rights reserved.
+
+This software and its source code are the exclusive property of Free Pro and are intended for internal use only.
+
+Unauthorized copying, distribution, modification, or use of this software, in whole or in part, is strictly prohibited without prior written permission from Free Pro.
+
+For questions or requests, contact:
+Free Pro
+[mathis.lambert@freepro.com]