documente_shared 0.1.200b0__tar.gz → 0.1.200b2__tar.gz

{documente_shared-0.1.200b0 → documente_shared-0.1.200b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: documente_shared
-Version: 0.1.200b0
+Version: 0.1.200b2
 Summary: Shared utilities for LlamitAI projects
 Author-email: Tech <tech@llamitai.com>
 License: MIT

{documente_shared-0.1.200b0 → documente_shared-0.1.200b2}/documente_shared/domain/entities/layout.py

@@ -75,3 +75,11 @@ class PageRange(BaseModel):
     end: Optional[int] = None
 
     model_config = ConfigDict(extra="ignore")
+
+    @property
+    def label(self) -> str:
+        # Espeja PageRange.label de las lambdas, que lo usan para nombrar el resultado en S3:
+        # start ausente es 1, end ausente es "end".
+        start_page = self.start if self.start is not None else 1
+        end_page = self.end if self.end is not None else "end"
+        return f"{start_page}-{end_page}"

documente_shared-0.1.200b2/documente_shared/infrastructure/lambda_job_results.py

@@ -0,0 +1,38 @@
+import time
+
+from documente_shared.infrastructure.s3_bucket import S3Bucket
+
+DEFAULT_JOB_RESULT_TIMEOUT = 960
+DEFAULT_JOB_RESULT_POLL_INTERVAL = 5
+
+
+def build_job_result_key(job_id: str, step_name: str) -> str:
+    # Contrato de S3JobResultStore en las lambdas: el mismo output_uri que devuelve la invocacion
+    # sincronica, construido aca para que la asincronica no dependa de una respuesta.
+    return f"jobs/{job_id}/{step_name}.json"
+
+
+def discard_previous_job_result(s3_bucket: S3Bucket, job_result_key: str) -> None:
+    # Sin esto la espera puede leer el resultado de una corrida anterior y devolverlo como propio.
+    # Lo que se borra es un artefacto derivado que la lambda reescribe en cada corrida, incluso en
+    # cache hit: su cache real no vive en este archivo.
+    s3_bucket.delete(file_key=job_result_key)
+
+
+def wait_for_job_result(
+    s3_bucket: S3Bucket,
+    job_result_key: str,
+    timeout_seconds: int = DEFAULT_JOB_RESULT_TIMEOUT,
+    poll_interval_seconds: float = DEFAULT_JOB_RESULT_POLL_INTERVAL,
+) -> dict:
+    deadline = time.monotonic() + timeout_seconds
+    while True:
+        job_result = s3_bucket.get_json(file_key=job_result_key)
+        if job_result is not None:
+            return job_result
+        if time.monotonic() >= deadline:
+            raise TimeoutError(
+                f"Lambda job result not found after {timeout_seconds}s: "
+                f"s3://{s3_bucket.bucket_name}/{job_result_key}"
+            )
+        time.sleep(poll_interval_seconds)

documente_shared-0.1.200b2/documente_shared/infrastructure/lambdas.py

@@ -0,0 +1,69 @@
+import json
+from functools import lru_cache
+
+import boto3
+from botocore.config import Config
+
+# Synchronous invocations travel through a PrivateLink interface endpoint, whose idle timeout is a
+# hard, non configurable 350s. A synchronous invoke leaves the flow completely idle while the
+# function runs, so past that point the flow is silently dropped and the response can never arrive.
+# Waiting any longer than the endpoint allows only delays a failure that already happened.
+DEFAULT_LAMBDA_READ_TIMEOUT = 350
+
+# An asynchronous invocation only enqueues the event, so the call returns in milliseconds no matter
+# how long the function then runs.
+DEFAULT_LAMBDA_ENQUEUE_TIMEOUT = 60
+
+
+@lru_cache(maxsize=None)
+def _get_lambda_client(read_timeout: int):
+    # No retries: the read timeout is shorter than the function timeout, so a read timeout means the
+    # invocation is still running on the other side. Retrying it would start a second execution of a
+    # function that is not idempotent.
+    lambda_config = Config(
+        read_timeout=read_timeout,
+        connect_timeout=30,
+        tcp_keepalive=True,
+        retries={"max_attempts": 0, "mode": "standard"},
+    )
+    return boto3.client("lambda", config=lambda_config)
+
+
+def invoke_lambda(
+    function_name: str,
+    payload: dict,
+    read_timeout: int = DEFAULT_LAMBDA_READ_TIMEOUT,
+) -> dict | list | None:
+    client = _get_lambda_client(read_timeout)
+
+    response = client.invoke(
+        FunctionName=function_name,
+        InvocationType="RequestResponse",
+        Payload=json.dumps(payload),
+    )
+
+    return json.loads(response["Payload"].read().decode("utf-8"))
+
+
+def invoke_lambda_async(
+    function_name: str,
+    payload: dict,
+    read_timeout: int = DEFAULT_LAMBDA_ENQUEUE_TIMEOUT,
+) -> int:
+    # There is no response payload to wait for, so the caller never holds a connection open while the
+    # function runs. The result travels out of band: the function writes it to its own deterministic
+    # output location and the caller reads it from there.
+    #
+    # Lambda retries a failed asynchronous invocation by itself (MaximumRetryAttempts defaults to 2
+    # on the function's event invoke config) and silently drops events it cannot deliver. Both are
+    # function side settings, invisible from here, so anything invoked this way has to tolerate
+    # running more than once for the same payload.
+    client = _get_lambda_client(read_timeout)
+
+    response = client.invoke(
+        FunctionName=function_name,
+        InvocationType="Event",
+        Payload=json.dumps(payload),
+    )
+
+    return response["StatusCode"]

{documente_shared-0.1.200b0 → documente_shared-0.1.200b2}/documente_shared/infrastructure/s3_bucket.py

@@ -1,4 +1,7 @@
 import boto3
+import json
+
+from botocore.exceptions import ClientError
 
 from dataclasses import dataclass
 from typing import Optional
@@ -7,6 +10,9 @@ from documente_shared.domain.entities.document import remove_slash_from_path
 from documente_shared.application.retry_utils import retry_on_size_integrity
 
 
+MISSING_OBJECT_ERROR_CODES = ("NoSuchKey", "404")
+
+
 def remove_none_values(data: dict) -> dict:  # noqa: WPS110
     return {key: value for key, value in data.items() if value is not None}  # noqa: WPS110
 
@@ -39,6 +45,18 @@ class S3Bucket(object):
             return None
         return file_context["Body"] if "Body" in file_context else None
 
+    def get_json(self, file_key: str) -> Optional[dict]:
+        # Sin el retry de get(): aca la ausencia del objeto es una respuesta valida y no algo que
+        # convenga reintentar, asi que se puede usar para preguntar si un resultado ya esta.
+        cleaned_file_key = remove_slash_from_path(file_key)
+        try:
+            file_context = self._resource.Object(self.bucket_name, cleaned_file_key).get()
+        except ClientError as client_error:
+            if client_error.response["Error"]["Code"] in MISSING_OBJECT_ERROR_CODES:
+                return None
+            raise
+        return json.loads(file_context["Body"].read().decode("utf-8"))
+
     def upload(self, file_key: str, file_content, content_type: Optional[str] = None):
         cleaned_file_key = remove_slash_from_path(file_key)
         optional_params = {"ContentType": content_type}

{documente_shared-0.1.200b0 → documente_shared-0.1.200b2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "documente_shared"
-version = "0.1.200b"
+version = "0.1.200b2"
 description = "Shared utilities for LlamitAI projects"
 authors = [{ name = "Tech", email = "tech@llamitai.com" }]
 license = { text = "MIT" }

{documente_shared-0.1.200b0 → documente_shared-0.1.200b2}/uv.lock

@@ -154,7 +154,7 @@ wheels = [
 
 [[package]]
 name = "documente-shared"
-version = "0.1.200b0"
+version = "0.1.200b2"
 source = { editable = "." }
 dependencies = [
     { name = "boto3" },

documente_shared-0.1.200b0/documente_shared/infrastructure/lambdas.py

@@ -1,37 +0,0 @@
-import json
-from functools import lru_cache
-
-import boto3
-from botocore.config import Config
-
-DEFAULT_LAMBDA_READ_TIMEOUT = 900
-
-
-@lru_cache(maxsize=None)
-def _get_lambda_client(read_timeout: int):
-    # Invocations are long running and not idempotent: the read timeout must outlast the target
-    # function timeout and retries must stay disabled, so a slow response never triggers a second
-    # invocation of the same job.
-    lambda_config = Config(
-        read_timeout=read_timeout,
-        connect_timeout=10,
-        tcp_keepalive=True,
-        retries={"max_attempts": 0, "mode": "standard"},
-    )
-    return boto3.client("lambda", config=lambda_config)
-
-
-def invoke_lambda(
-    function_name: str,
-    payload: dict,
-    read_timeout: int = DEFAULT_LAMBDA_READ_TIMEOUT,
-) -> dict | list | None:
-    client = _get_lambda_client(read_timeout)
-
-    response = client.invoke(
-        FunctionName=function_name,
-        InvocationType="RequestResponse",
-        Payload=json.dumps(payload),
-    )
-
-    return json.loads(response["Payload"].read().decode("utf-8"))