unstructured-platform-plugins 0.1.0__tar.gz → 0.1.1.dev1__tar.gz

{unstructured_platform_plugins-0.1.0 → unstructured_platform_plugins-0.1.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unstructured_platform_plugins
-Version: 0.1.0
+Version: 0.1.1.dev1
 Summary: Wrapper to convert arbitrary code into a uvicorn/fastapi implementation for Unstructured Platform
 License-File: LICENSE.md
 Classifier: Development Status :: 4 - Beta

unstructured_platform_plugins-0.1.1.dev1/unstructured_platform_plugins/__init__.py

@@ -0,0 +1,13 @@
+from unstructured_platform_plugins.invocation_scope import (
+    InvocationIdentity,
+    current_invocation_identity,
+    invocation_scratch_dir,
+)
+from unstructured_platform_plugins.invocation_settings import current_invocation_context
+
+__all__ = [
+    "InvocationIdentity",
+    "current_invocation_context",
+    "current_invocation_identity",
+    "invocation_scratch_dir",
+]

unstructured_platform_plugins-0.1.1.dev1/unstructured_platform_plugins/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1.dev1"  # pragma: no cover

{unstructured_platform_plugins-0.1.0 → unstructured_platform_plugins-0.1.1.dev1}/unstructured_platform_plugins/etl_uvicorn/api_generator.py

@@ -3,6 +3,7 @@ import hashlib
 import inspect
 import json
 import logging
+import re
 from typing import Any, Callable, Optional, Union, get_origin
 
 from fastapi import FastAPI, HTTPException, status
@@ -12,7 +13,7 @@ from pydantic import BaseModel, Field, create_model
 from starlette.responses import RedirectResponse
 from typing_extensions import deprecated
 from unstructured_ingest.data_types.file_data import BatchFileData, FileData, file_data_from_dict
-from unstructured_ingest.error import UnstructuredIngestError, UserError
+from unstructured_ingest.error import RateLimitError, UnstructuredIngestError, UserError
 from uvicorn.config import LOG_LEVELS
 from uvicorn.importer import import_from_string
 
@@ -111,19 +112,54 @@ def failure_category_of(error: BaseException) -> Optional[str]:
     return category if isinstance(category, str) else None
 
 
+def _as_error_reason(category: Optional[str]) -> Optional[str]:
+    """Render a failure_category as an ``error.reason`` token, or None when it cannot be.
+
+    ``failure_category`` and ``error.reason`` are two vocabularies, not one: the preflight
+    categories are SCREAMING_SNAKE (``AUTH_PERMISSION_DENIED``) while ``error.reason`` is
+    specified lower_snake_case. ``failure_category`` still rides its own top-level response
+    field verbatim, so nothing is lost by normalizing the copy that lands here.
+
+    The category is plugin-supplied free text rather than a closed enum, so lowercasing
+    alone would not produce a snake_case token; punctuation and whitespace collapse to
+    single underscores and a category with no usable characters yields None.
+    """
+    if category is None:
+        return None
+    # -- str.lower, not category.lower: the isinstance check upstream admits str SUBCLASSES,
+    # -- and this renders an error response, where raising is the one thing it must not do --
+    reason = re.sub(r"[^a-z0-9]+", "_", str.lower(category)).strip("_")
+    return reason or None
+
+
 def plugin_error_of(error: BaseException) -> Optional[PluginErrorMetadata]:
     """Map the legacy UserError family onto the canonical plugin-error envelope.
 
     The ratified ErrorAudience vocabulary owns the wire spelling. A non-user failure remains
     unclassified: orchestrators must not infer actionability from its HTTP status.
+
+    Terminal is the safe default, so a transient condition has to declare itself: a provider
+    rate limit is the one member of this family that clears on its own, and it mirrors the
+    utic_plugin_base ``RateLimitError`` declaration (platform-libs #889) field for field.
+    Retryability is orthogonal to audience -- a throttled request is still the caller's
+    quota, so the audience stays ``user``.
+
+    The class picks the DEFAULT reason; an explicit ``failure_category`` still wins, on this
+    branch as on every other. A plugin that declares a category has said something more
+    specific than the class did (a rate limit raised as ``PROVIDER_RATE_LIMITED``), and
+    dropping it here would discard the more precise of the two.
     """
     if not isinstance(error, UserError):
         return None
+    if isinstance(error, RateLimitError):
+        error_type, default_reason, retryable = "dependency", "rate_limited", True
+    else:
+        error_type, default_reason, retryable = "configuration", "invalid_input", False
     return PluginErrorMetadata(
-        error_type="configuration",
-        error_reason=failure_category_of(error) or "invalid_input",
+        error_type=error_type,
+        error_reason=_as_error_reason(failure_category_of(error)) or default_reason,
         audience=ErrorAudience.USER,
-        retryable=False,
+        retryable=retryable,
     )
 
 

unstructured_platform_plugins-0.1.1.dev1/unstructured_platform_plugins/invocation_scope.py

@@ -0,0 +1,63 @@
+"""Identity and filesystem scope for the current invocation."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+from dataclasses import dataclass, fields
+from pathlib import Path
+from uuid import uuid4
+
+from unstructured_platform_plugins.invocation_settings import current_invocation_context
+
+
+@dataclass(frozen=True)
+class InvocationIdentity:
+    job_id: str | None
+    tenant_id: str | None
+    org_id: str | None
+    workflow_id: str | None
+    attribution_id: str | None
+    dag_node_id: str | None
+    dag_node_type: str | None
+    dag_node_subtype: str | None
+
+
+def current_invocation_identity() -> InvocationIdentity:
+    """Read identity from the bound context, or the environment when no context is bound."""
+    context = current_invocation_context()
+    values = {}
+    for field in fields(InvocationIdentity):
+        values[field.name] = (
+            getattr(context, field.name, None)
+            if context is not None
+            else os.getenv(field.name.upper())
+        )
+    return InvocationIdentity(**values)
+
+
+def _segment(value: str | None) -> str:
+    if not value:
+        return "unknown"
+    safe = re.sub(r"[^a-zA-Z0-9_.-]", "_", value)
+    if safe in {".", ".."} or safe != value or len(safe) > 96:
+        digest = hashlib.sha256(value.encode()).hexdigest()[:16]
+        safe = f"{safe[:79].strip('.') or 'unknown'}-{digest}"
+    return safe
+
+
+def invocation_scratch_dir(root: str | os.PathLike[str], *, create: bool = True) -> Path:
+    """Return an invocation directory, or the unchanged root when no context is bound."""
+    path = Path(root)
+    context = current_invocation_context()
+    if context is not None:
+        identity = current_invocation_identity()
+        invocation_id = context.invocation_id
+        if not invocation_id and context.record_ids is None and context.invocation_ids is None:
+            invocation_id = context.record_id
+        path = path / _segment(identity.job_id) / _segment(identity.dag_node_id)
+        path = path / _segment(invocation_id or uuid4().hex)
+    if create:
+        path.mkdir(parents=True, exist_ok=True)
+    return path

unstructured_platform_plugins-0.1.0/unstructured_platform_plugins/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"  # pragma: no cover