docu-devs-api-client 1.9.0__tar.gz → 1.9.1__tar.gz

{docu_devs_api_client-1.9.0 → docu_devs_api_client-1.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docu-devs-api-client
-Version: 1.9.0
+Version: 1.9.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
@@ -20,7 +20,7 @@ Requires-Python: <4.0,>=3.9
 Requires-Dist: asyncio>=3.4.3
 Requires-Dist: attrs>=21.3.0
 Requires-Dist: click>=8.0.0
-Requires-Dist: httpx<0.28.1,>=0.20.0
+Requires-Dist: httpx<1.0.0,>=0.28.1
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dateutil>=2.8.0
 Provides-Extra: dev

{docu_devs_api_client-1.9.0 → docu_devs_api_client-1.9.1}/cli.py

@@ -591,6 +591,24 @@ async def billing_balance(ctx):
     result = await ctx.obj["client"].get_billing_balance()
     _echo_response(result)
 
+
+@billing.command("usage-events")
+@click.argument("guids")
+@click.option("--limit", default=500, show_default=True, type=int)
+@click.option("--include-related/--no-include-related", default=True, show_default=True)
+@click.pass_context
+@async_command
+async def billing_usage_events(ctx, guids: str, limit: int, include_related: bool):
+    """List raw usage events for comma-separated job GUIDs."""
+    guid_list = [value.strip() for value in guids.split(",") if value.strip()]
+    result = await ctx.obj["client"].get_billing_usage_events(
+        guid_list,
+        include_related=include_related,
+        limit=limit,
+    )
+    _echo_response(result)
+
+
 @cli.command()
 @click.argument("guid")
 @click.pass_context
@@ -645,6 +663,45 @@ async def delete_configuration(ctx, name: str):
     _echo_response(result)
 
 
+@cli.group("configuration")
+@click.pass_context
+def configuration_group(ctx):
+    """Manage configuration attachments."""
+    pass
+
+
+@configuration_group.group("lookup-file")
+@click.pass_context
+def configuration_lookup_file(ctx):
+    """Manage configuration lookup files."""
+    pass
+
+
+@configuration_lookup_file.command("upload")
+@click.argument("name")
+@click.argument("file", type=click.Path(exists=True))
+@click.pass_context
+@async_command
+async def configuration_lookup_file_upload(ctx, name: str, file: str):
+    file_path = Path(file)
+    payload = file_path.read_bytes()
+    result = await ctx.obj["client"].upload_configuration_lookup_file(
+        name,
+        payload,
+        file_name=file_path.name,
+    )
+    _echo_response(result)
+
+
+@configuration_lookup_file.command("delete")
+@click.argument("name")
+@click.pass_context
+@async_command
+async def configuration_lookup_file_delete(ctx, name: str):
+    result = await ctx.obj["client"].delete_configuration_lookup_file(name)
+    _echo_response(result)
+
+
 # Template commands
 @cli.command()
 @click.pass_context
@@ -1247,7 +1304,8 @@ def batch(ctx):
 @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("--configuration", default=None, help="Named configuration for configuration-backed batch processing")
+@click.option("--lookup-file", type=click.Path(exists=True), default=None, help="Optional batch-scoped lookup file that overrides any configuration lookup for this batch")
 @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
@@ -1269,6 +1327,7 @@ async def batch_process(
     result_format: Optional[str],
     output: Optional[str],
     configuration: Optional[str],
+    lookup_file: Optional[str],
     timeout: int,
     wait: bool,
 ):
@@ -1312,17 +1371,32 @@ async def batch_process(
             )
             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,
-        )
+        if lookup_file:
+            await client.upload_batch_lookup_file(batch_guid, lookup_file)
+            click.echo(f"  Uploaded batch lookup file {Path(lookup_file).name}")
+
+        if configuration:
+            if prompt_text.strip():
+                raise click.BadParameter("--prompt/--prompt-file cannot be used with --configuration", param_hint="--configuration")
+            if schema_text.strip():
+                raise click.BadParameter("--schema/--schema-file cannot be used with --configuration", param_hint="--configuration")
+            if barcodes_value is not None or extraction_mode or describe_value:
+                raise click.BadParameter("Processing flags cannot be combined with --configuration", param_hint="--configuration")
+            if ocr is not None or llm is not None:
+                raise click.BadParameter("--ocr and --llm cannot be combined with --configuration", param_hint="--configuration")
+            await client.process_batch_with_configuration(batch_guid, configuration)
+        else:
+            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

docu_devs_api_client-1.9.1/docudevs/api/batch/delete_batch_lookup_file.py

@@ -0,0 +1,92 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...types import Response
+
+
+def _get_kwargs(
+    guid: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": f"/document/batch/{guid}/lookup-file",
+    }
+
+    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(
+    guid: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Response[Any]:
+    """
+    Args:
+        guid (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(
+        guid=guid,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    guid: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Response[Any]:
+    """
+    Args:
+        guid (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(
+        guid=guid,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)

docu_devs_api_client-1.9.1/docudevs/api/batch/download_batch_lookup_file.py

@@ -0,0 +1,142 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...types import Response
+
+
+def _get_kwargs(
+    guid: str,
+) -> dict[str, Any]:
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": f"/document/batch/{guid}/lookup-file",
+    }
+
+    return _kwargs
+
+
+def _parse_response(*, client: Union[AuthenticatedClient, Client], response: httpx.Response) -> Optional[list[str]]:
+    if response.status_code == 200:
+        response_200 = cast(list[str], 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[list[str]]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    guid: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Response[list[str]]:
+    """
+    Args:
+        guid (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[list[str]]
+    """
+
+    kwargs = _get_kwargs(
+        guid=guid,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    guid: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Optional[list[str]]:
+    """
+    Args:
+        guid (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:
+        list[str]
+    """
+
+    return sync_detailed(
+        guid=guid,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    guid: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Response[list[str]]:
+    """
+    Args:
+        guid (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[list[str]]
+    """
+
+    kwargs = _get_kwargs(
+        guid=guid,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    guid: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+) -> Optional[list[str]]:
+    """
+    Args:
+        guid (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:
+        list[str]
+    """
+
+    return (
+        await asyncio_detailed(
+            guid=guid,
+            client=client,
+        )
+    ).parsed

docu_devs_api_client-1.9.1/docudevs/api/batch/process_batch_with_configuration.py

@@ -0,0 +1,186 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.batch_create_response import BatchCreateResponse
+from ...types import UNSET, Response, Unset
+
+
+def _get_kwargs(
+    guid: str,
+    configuration_name: str,
+    *,
+    trace: Union[None, Unset, bool] = UNSET,
+) -> dict[str, Any]:
+    params: dict[str, Any] = {}
+
+    json_trace: Union[None, Unset, bool]
+    if isinstance(trace, Unset):
+        json_trace = UNSET
+    else:
+        json_trace = trace
+    params["trace"] = json_trace
+
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/document/batch/{guid}/process/with-configuration/{configuration_name}",
+        "params": params,
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[BatchCreateResponse]:
+    if response.status_code == 200:
+        response_200 = BatchCreateResponse.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[BatchCreateResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    guid: str,
+    configuration_name: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+    trace: Union[None, Unset, bool] = UNSET,
+) -> Response[BatchCreateResponse]:
+    """
+    Args:
+        guid (str):
+        configuration_name (str):
+        trace (Union[None, Unset, bool]):
+
+    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[BatchCreateResponse]
+    """
+
+    kwargs = _get_kwargs(
+        guid=guid,
+        configuration_name=configuration_name,
+        trace=trace,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    guid: str,
+    configuration_name: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+    trace: Union[None, Unset, bool] = UNSET,
+) -> Optional[BatchCreateResponse]:
+    """
+    Args:
+        guid (str):
+        configuration_name (str):
+        trace (Union[None, Unset, bool]):
+
+    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:
+        BatchCreateResponse
+    """
+
+    return sync_detailed(
+        guid=guid,
+        configuration_name=configuration_name,
+        client=client,
+        trace=trace,
+    ).parsed
+
+
+async def asyncio_detailed(
+    guid: str,
+    configuration_name: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+    trace: Union[None, Unset, bool] = UNSET,
+) -> Response[BatchCreateResponse]:
+    """
+    Args:
+        guid (str):
+        configuration_name (str):
+        trace (Union[None, Unset, bool]):
+
+    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[BatchCreateResponse]
+    """
+
+    kwargs = _get_kwargs(
+        guid=guid,
+        configuration_name=configuration_name,
+        trace=trace,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    guid: str,
+    configuration_name: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+    trace: Union[None, Unset, bool] = UNSET,
+) -> Optional[BatchCreateResponse]:
+    """
+    Args:
+        guid (str):
+        configuration_name (str):
+        trace (Union[None, Unset, bool]):
+
+    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:
+        BatchCreateResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            guid=guid,
+            configuration_name=configuration_name,
+            client=client,
+            trace=trace,
+        )
+    ).parsed

docu_devs_api_client-1.9.1/docudevs/api/batch/upload_batch_lookup_file.py

@@ -0,0 +1,106 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.upload_batch_lookup_file_body import UploadBatchLookupFileBody
+from ...types import Response
+
+
+def _get_kwargs(
+    guid: str,
+    *,
+    body: UploadBatchLookupFileBody,
+) -> dict[str, Any]:
+    headers: dict[str, Any] = {}
+
+    _kwargs: dict[str, Any] = {
+        "method": "post",
+        "url": f"/document/batch/{guid}/lookup-file",
+    }
+
+    _kwargs["files"] = body.to_multipart()
+
+    _kwargs["headers"] = headers
+    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(
+    guid: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: UploadBatchLookupFileBody,
+) -> Response[Any]:
+    """
+    Args:
+        guid (str):
+        body (UploadBatchLookupFileBody):
+
+    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(
+        guid=guid,
+        body=body,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio_detailed(
+    guid: str,
+    *,
+    client: Union[AuthenticatedClient, Client],
+    body: UploadBatchLookupFileBody,
+) -> Response[Any]:
+    """
+    Args:
+        guid (str):
+        body (UploadBatchLookupFileBody):
+
+    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(
+        guid=guid,
+        body=body,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)