docu-devs-api-client 1.6.1__tar.gz → 1.7.1__tar.gz

{docu_devs_api_client-1.6.1 → docu_devs_api_client-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docu-devs-api-client
-Version: 1.6.1
+Version: 1.7.1
 Summary: A client library for accessing DocuDevs API
 Project-URL: Homepage, https://www.docudevs.ai/
 Project-URL: Repository, https://github.com/piizei/docudevs.git

{docu_devs_api_client-1.6.1 → docu_devs_api_client-1.7.1}/cli.py

@@ -294,6 +294,18 @@ async def process(
 @click.option("--pages-per-chunk", type=int, default=1, show_default=True, help="Pages per chunk for map-reduce")
 @click.option("--overlap", type=int, default=0, show_default=True, help="Overlapping pages between chunks")
 @click.option("--dedup-key", help="JSON path to deduplicate rows across chunks")
+@click.option(
+    "--split-type",
+    type=click.Choice(["page", "markdown-header"]),
+    default="page",
+    show_default=True,
+    help="Chunk split strategy",
+)
+@click.option(
+    "--split-header-level",
+    type=click.IntRange(1, 2),
+    help="Markdown header level for --split-type markdown-header",
+)
 @click.option("--header-page-limit", type=int, help="Number of pages reserved for header extraction")
 @click.option("--header-include-in-rows", is_flag=True, default=False, help="Include header pages in row processing")
 @click.option("--header-row-prompt-augmentation", help="Additional context added to each chunk prompt")
@@ -329,6 +341,8 @@ async def process_map_reduce(
     pages_per_chunk: int,
     overlap: int,
     dedup_key: Optional[str],
+    split_type: str,
+    split_header_level: Optional[int],
     header_page_limit: Optional[int],
     header_include_in_rows: bool,
     header_row_prompt_augmentation: Optional[str],
@@ -386,6 +400,7 @@ async def process_map_reduce(
         header_options["row_prompt_augmentation"] = header_row_prompt_augmentation
     if header_page_indices:
         header_options["page_indices"] = list(header_page_indices)
+    normalized_split_type = split_type.replace("-", "_")
 
     client: DocuDevsClient = ctx.obj["client"]
     try:
@@ -402,6 +417,8 @@ async def process_map_reduce(
             pages_per_chunk=pages_per_chunk,
             overlap_pages=overlap,
             dedup_key=dedup_key,
+            split_type=normalized_split_type,
+            split_header_level=split_header_level,
             header_options=header_options or None,
             header_schema=header_schema_text,
             header_prompt=header_prompt,
@@ -1186,5 +1203,144 @@ async def bind_ocr_key(ctx, key, provider_id):
     click.echo(resp.status_code)
 
 
+# ---------------- Batch Processing ----------------
+@cli.group()
+@click.pass_context
+def batch(ctx):
+    """Batch processing for multiple documents."""
+    pass
+
+
+@batch.command("process")
+@click.argument("files", nargs=-1, required=True, type=click.Path(exists=True))
+@click.option("--prompt", default="", help="Extraction prompt")
+@click.option("--prompt-file", type=click.Path(exists=True), help="Path to a text file containing extraction instructions")
+@click.option("--schema", default="", help="JSON schema for extraction")
+@click.option("--schema-file", type=click.Path(exists=True), help="Path to a JSON schema file")
+@click.option("--mime-type", help="Explicit MIME type for all documents")
+@click.option("--ocr", type=click.Choice(["DEFAULT", "NONE", "PREMIUM", "AUTO", "EXCEL"]), default=None, help="OCR type")
+@click.option("--llm", type=click.Choice(["DEFAULT", "MINI", "HIGH"]), default=None, help="LLM type")
+@click.option("--barcodes", is_flag=True, default=False, help="Enable barcode and QR code detection")
+@click.option("--extraction-mode", type=click.Choice(["OCR", "SIMPLE", "STEPS"]), default=None, help="Extraction mode override")
+@click.option("--describe-figures", is_flag=True, default=False, help="Request figure descriptions when supported")
+@click.option("--max-concurrency", type=int, default=None, help="Maximum concurrent document processing")
+@click.option("--format", "result_format", type=click.Choice(["json", "csv", "excel"]), default=None, help="Output format for results (implies --wait)")
+@click.option("--output", type=click.Path(), help="Save results to file (auto-generated if --format is set without --output)")
+@click.option("--configuration", default=None, help="Named configuration for Excel template injection")
+@click.option("--timeout", default=300, help="Timeout in seconds")
+@click.option("--wait/--no-wait", default=True, help="Wait for processing to complete")
+@click.pass_context
+@async_command
+async def batch_process(
+    ctx,
+    files: tuple[str, ...],
+    prompt: str,
+    prompt_file: Optional[str],
+    schema: str,
+    schema_file: Optional[str],
+    mime_type: Optional[str],
+    ocr: Optional[str],
+    llm: Optional[str],
+    barcodes: bool,
+    extraction_mode: Optional[str],
+    describe_figures: bool,
+    max_concurrency: Optional[int],
+    result_format: Optional[str],
+    output: Optional[str],
+    configuration: Optional[str],
+    timeout: int,
+    wait: bool,
+):
+    """Upload and process multiple documents as a batch."""
+    import mimetypes
+
+    prompt_text = prompt
+    if prompt_file:
+        if prompt:
+            raise click.BadParameter("Use either --prompt or --prompt-file, not both.", param_hint="--prompt-file")
+        prompt_text = Path(prompt_file).read_text()
+
+    schema_text = schema
+    if schema_file:
+        if schema:
+            raise click.BadParameter("Use either --schema or --schema-file, not both.", param_hint="--schema-file")
+        schema_text = Path(schema_file).read_text()
+
+    barcodes_value: Optional[bool] = True if barcodes else None
+    describe_value: Optional[bool] = True if describe_figures else None
+
+    first_file = Path(files[0])
+    effective_mime = mime_type or mimetypes.guess_type(first_file.name)[0] or "application/octet-stream"
+
+    client: DocuDevsClient = ctx.obj["client"]
+
+    try:
+        batch_guid = await client.create_batch(max_concurrency=max_concurrency)
+        click.echo(f"Batch created. GUID: {batch_guid}")
+
+        for file_path_str in files:
+            file_path = Path(file_path_str)
+            doc_mime = mime_type or mimetypes.guess_type(file_path.name)[0] or effective_mime
+            with open(file_path, "rb") as f:
+                document_data = f.read()
+            upload_result = await client.upload_batch_document(
+                batch_guid,
+                document_data,
+                doc_mime,
+                file_name=file_path.name,
+            )
+            click.echo(f"  Uploaded {file_path.name} (index {upload_result.get('index', '?')})")
+
+        await client.process_batch(
+            batch_guid,
+            prompt=prompt_text,
+            schema=schema_text,
+            mime_type=effective_mime,
+            ocr=ocr,
+            barcodes=barcodes_value,
+            llm=llm,
+            extraction_mode=extraction_mode,
+            describe_figures=describe_value,
+        )
+        click.echo(f"Batch processing started. GUID: {batch_guid}")
+
+        should_wait = wait or result_format is not None
+        if should_wait:
+            click.echo("Waiting for batch to complete...")
+
+            format_extensions = {"json": ".json", "csv": ".csv", "excel": ".xlsx"}
+            output_path = output
+            if result_format and not output_path:
+                output_path = f"batch-{batch_guid}{format_extensions.get(result_format, '')}"
+
+            excel_save_to = output_path if result_format == "excel" else None
+
+            result = await client.wait_until_ready(
+                batch_guid,
+                timeout=timeout,
+                result_format=result_format,
+                excel_save_to=excel_save_to,
+                excel_configuration=configuration,
+            )
+
+            if output_path and result_format != "excel":
+                if isinstance(result, (bytes, bytearray)):
+                    Path(output_path).write_bytes(result)
+                elif isinstance(result, str):
+                    Path(output_path).write_text(result)
+                else:
+                    Path(output_path).write_text(json.dumps(_as_serializable(result), indent=2))
+
+            if output_path:
+                click.echo(f"Saved to {output_path}")
+            else:
+                _echo_response(result)
+        else:
+            click.echo("Use 'status' and 'result' commands to check progress and get results.")
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return 1
+
+
 if __name__ == "__main__":
     cli()

{docu_devs_api_client-1.6.1 → docu_devs_api_client-1.7.1}/docudevs/__init__.py

@@ -2,6 +2,7 @@
 
 from .client import AuthenticatedClient, Client
 from .docudevs_client import DocuDevsClient, UploadDocumentBody, UploadCommand, File, UploadFilesBody, TemplateFillRequest
+from .schema import array_schema, json_schema
 
 __all__ = (
     "AuthenticatedClient",
@@ -12,4 +13,6 @@ __all__ = (
     "File",
     "UploadFilesBody",
     "TemplateFillRequest",
+    "array_schema",
+    "json_schema",
 )

docu_devs_api_client-1.7.1/docudevs/api/billing/get_recent_ledger.py

@@ -0,0 +1,175 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.ledger_entry_response import LedgerEntryResponse
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    *,
+    org_id: str,
+    limit: int = 50,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["orgId"] = org_id
+
+    params["limit"] = limit
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/billing/usage/ledger",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[list["LedgerEntryResponse"]]:
+    if response.status_code == 200:
+        response_200 = []
+        _response_200 = response.json()
+        for response_200_item_data in _response_200:
+            response_200_item = LedgerEntryResponse.from_dict(response_200_item_data)
+
+            response_200.append(response_200_item)
+
+        return response_200
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[list["LedgerEntryResponse"]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    org_id: str,
+    limit: int = 50,
+) -> Response[list["LedgerEntryResponse"]]:
+    """
+    Args:
+        org_id (str):
+        limit (int):  Default: 50.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[list['LedgerEntryResponse']]
+    """
+
+    kwargs = _get_kwargs(
+        org_id=org_id,
+        limit=limit,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    org_id: str,
+    limit: int = 50,
+) -> Optional[list["LedgerEntryResponse"]]:
+    """
+    Args:
+        org_id (str):
+        limit (int):  Default: 50.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        list['LedgerEntryResponse']
+    """
+
+    return sync_detailed(
+        client=client,
+        org_id=org_id,
+        limit=limit,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    org_id: str,
+    limit: int = 50,
+) -> Response[list["LedgerEntryResponse"]]:
+    """
+    Args:
+        org_id (str):
+        limit (int):  Default: 50.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[list['LedgerEntryResponse']]
+    """
+
+    kwargs = _get_kwargs(
+        org_id=org_id,
+        limit=limit,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    org_id: str,
+    limit: int = 50,
+) -> Optional[list["LedgerEntryResponse"]]:
+    """
+    Args:
+        org_id (str):
+        limit (int):  Default: 50.
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        list['LedgerEntryResponse']
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            org_id=org_id,
+            limit=limit,
+        )
+    ).parsed

docu_devs_api_client-1.7.1/docudevs/api/billing/get_usage_by_jobs.py

@@ -0,0 +1,109 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    *,
+    org_id: str,
+    guids: str,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["orgId"] = org_id
+
+    params["guids"] = guids
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/billing/usage/by-jobs",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Optional[Any]:
+    if response.status_code == 200:
+        return None
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Response[Any]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    org_id: str,
+    guids: str,
+) -> Response[Any]:
+    """
+    Args:
+        org_id (str):
+        guids (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        org_id=org_id,
+        guids=guids,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    org_id: str,
+    guids: str,
+) -> Response[Any]:
+    """
+    Args:
+        org_id (str):
+        guids (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any]
+    """
+
+    kwargs = _get_kwargs(
+        org_id=org_id,
+        guids=guids,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)

docu_devs_api_client-1.7.1/docudevs/api/billing/get_usage_summary.py

@@ -0,0 +1,155 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.usage_summary_response import UsageSummaryResponse
+from ...types import UNSET, Response
+
+
+def _get_kwargs(
+    *,
+    org_id: str,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    params["orgId"] = org_id
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/billing/usage/summary",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[UsageSummaryResponse]:
+    if response.status_code == 200:
+        response_200 = UsageSummaryResponse.from_dict(response.json())
+
+        return response_200
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[UsageSummaryResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    org_id: str,
+) -> Response[UsageSummaryResponse]:
+    """
+    Args:
+        org_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[UsageSummaryResponse]
+    """
+
+    kwargs = _get_kwargs(
+        org_id=org_id,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    org_id: str,
+) -> Optional[UsageSummaryResponse]:
+    """
+    Args:
+        org_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        UsageSummaryResponse
+    """
+
+    return sync_detailed(
+        client=client,
+        org_id=org_id,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    org_id: str,
+) -> Response[UsageSummaryResponse]:
+    """
+    Args:
+        org_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[UsageSummaryResponse]
+    """
+
+    kwargs = _get_kwargs(
+        org_id=org_id,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    *,
+    client: Union[AuthenticatedClient, Client],
+    org_id: str,
+) -> Optional[UsageSummaryResponse]:
+    """
+    Args:
+        org_id (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        UsageSummaryResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            org_id=org_id,
+        )
+    ).parsed