documente_shared 0.1.161b5__tar.gz → 0.1.162__tar.gz

{documente_shared-0.1.161b5 → documente_shared-0.1.162}/.gitignore

@@ -2,4 +2,5 @@ dist/
 tmp/
 .env
 .env.*
-.idea/
+.idea/
+__pycache__/

documente_shared-0.1.162/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+  "python.analysis.extraPaths": [
+    "${workspaceFolder}"
+  ],
+  "python.autoComplete.extraPaths": [
+    "${workspaceFolder}"
+  ],
+  "terminal.integrated.env.osx": {
+    "PYTHONPATH": "${workspaceFolder}"
+  }
+}

{documente_shared-0.1.161b5 → documente_shared-0.1.162}/Dockerfile

@@ -20,6 +20,6 @@ WORKDIR /package
 
 COPY pyproject.toml uv.lock /package/
 
-RUN uv sync --no-install-project
+RUN uv sync --no-install-project --all-groups
 
 ENTRYPOINT []

{documente_shared-0.1.161b5 → documente_shared-0.1.162}/Makefile

@@ -5,6 +5,10 @@ COMPOSE_PACKAGE := @docker compose -f docker-compose.yml run --rm package
 
 ARG=
 
+setup:
+	uv sync --all-groups
+
+
 build:
 	$(COMPOSE) build
 
@@ -22,7 +26,7 @@ clean:
 	docker ps -aq | xargs docker rm
 
 test:
-	$(COMPOSE_PACKAGE) bash -c "pytest --pyargs $(ARG)"
+	$(COMPOSE_PACKAGE) bash -c "uv run pytest --pyargs $(ARG)"
 
 test_single:
-	$(COMPOSE_PACKAGE) bash -c "pytest --pyargs -m single"
+	$(COMPOSE_PACKAGE) bash -c "uv run pytest --pyargs -m single"

{documente_shared-0.1.161b5 → documente_shared-0.1.162}/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 2.4
 Name: documente_shared
-Version: 0.1.161b5
-Summary: Shared utilities for Documente AI projects
+Version: 0.1.162
+Summary: Shared utilities for LlamitAI projects
 Author-email: Tech <tech@llamitai.com>
 License: MIT
 Requires-Python: <3.13,>=3.10
-Requires-Dist: boto3>=1.42.24
-Requires-Dist: botocore>=1.42.24
-Requires-Dist: loguru>=0.7.3
-Requires-Dist: pytz>=2025.2
+Requires-Dist: boto3>=1.42.46
+Requires-Dist: botocore>=1.42.46
+Requires-Dist: pydantic>=2.12.5
 Requires-Dist: requests>=2.32.5
-Requires-Dist: sentry-sdk>=2.49.0
+Requires-Dist: sentry-sdk>=2.52.0
+Requires-Dist: structlog>=25.5.0
 Requires-Dist: unidecode>=1.4.0
 Description-Content-Type: text/markdown
 

documente_shared-0.1.162/documente_shared/application/dates.py

@@ -0,0 +1,5 @@
+from datetime import datetime, timezone
+
+
+def utc_now() -> datetime:
+    return datetime.now(tz=timezone.utc)

documente_shared-0.1.162/documente_shared/application/logging.py

@@ -0,0 +1,47 @@
+import sys
+import logging
+import structlog
+
+
+def configure_logging(environment: str = "dev") -> None:
+    is_production = environment in ("production", "staging")
+
+    shared_processors = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.add_logger_name,
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.UnicodeDecoder(),
+    ]
+
+    if is_production:
+        renderer = structlog.processors.JSONRenderer()
+    else:
+        renderer = structlog.dev.ConsoleRenderer()
+
+    structlog.configure(
+        processors=[
+            *shared_processors,
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,  # type: ignore[arg-type]
+        cache_logger_on_first_use=True,
+    )
+
+    formatter = structlog.stdlib.ProcessorFormatter(
+        processors=[
+            structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+            renderer,
+        ],
+        foreign_pre_chain=shared_processors,
+    )
+
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(formatter)
+
+    root_logger = logging.getLogger()
+    root_logger.handlers.clear()
+    root_logger.addHandler(handler)
+    root_logger.setLevel(logging.INFO)

{documente_shared-0.1.161b5 → documente_shared-0.1.162}/documente_shared/application/retry_utils.py

@@ -2,7 +2,9 @@ import time
 import random
 from functools import wraps
 from typing import Optional, Callable
-from loguru import logger
+import structlog
+
+logger = structlog.get_logger()
 
 
 def retry_on_size_integrity(base_delay: float = 0.8, max_retries: int = 3):
@@ -15,7 +17,10 @@ def retry_on_size_integrity(base_delay: float = 0.8, max_retries: int = 3):
 
                     if not file_context:
                         logger.warning(
-                            f"[Intento {attempt+1}/{max_retries}] file_context es None para {file_key}"
+                            "[shared.retry.file_context_none]",
+                            attempt=attempt + 1,
+                            max_retries=max_retries,
+                            file_key=file_key,
                         )
                         if attempt < max_retries - 1:
                             delay = base_delay * (2 ** attempt) + random.uniform(0, base_delay)
@@ -25,7 +30,10 @@ def retry_on_size_integrity(base_delay: float = 0.8, max_retries: int = 3):
 
                     if 'Body' not in file_context:
                         logger.warning(
-                            f"[Intento {attempt+1}/{max_retries}] 'Body' no encontrado en file_context para {file_key}"
+                            "[shared.retry.body_not_found]",
+                            attempt=attempt + 1,
+                            max_retries=max_retries,
+                            file_key=file_key,
                         )
                         if attempt < max_retries - 1:
                             delay = base_delay * (2 ** attempt) + random.uniform(0, base_delay)
@@ -40,12 +48,16 @@ def retry_on_size_integrity(base_delay: float = 0.8, max_retries: int = 3):
                     if expected_size == actual_size:
                         file_context['Body'] = body
                         if attempt > 0:
-                            logger.info(f"Descarga exitosa de {file_key} después de {attempt+1} intentos")
+                            logger.info("[shared.retry.download_success]", file_key=file_key, attempts=attempt + 1)
                         return file_context
 
                     logger.warning(
-                        f"[Intento {attempt+1}/{max_retries}] Discrepancia de tamaño para {file_key}: "
-                        f"esperado={expected_size}, recibido={actual_size}"
+                        "[shared.retry.size_mismatch]",
+                        attempt=attempt + 1,
+                        max_retries=max_retries,
+                        file_key=file_key,
+                        expected_size=expected_size,
+                        actual_size=actual_size,
                     )
 
                     if attempt < max_retries - 1:
@@ -54,7 +66,12 @@ def retry_on_size_integrity(base_delay: float = 0.8, max_retries: int = 3):
 
                 except Exception as e:
                     logger.error(
-                        f"[Intento {attempt+1}/{max_retries}] Error al descargar {file_key}: {type(e).__name__}: {str(e)}"
+                        "[shared.retry.download_error]",
+                        attempt=attempt + 1,
+                        max_retries=max_retries,
+                        file_key=file_key,
+                        error_type=type(e).__name__,
+                        error=str(e),
                     )
                     if attempt < max_retries - 1:
                         delay = base_delay * (2 ** attempt) + random.uniform(0, base_delay)

documente_shared-0.1.162/documente_shared/domain/constants.py

@@ -0,0 +1,10 @@
+from os import environ
+from zoneinfo import ZoneInfo
+
+
+la_paz_tz = ZoneInfo("America/La_Paz")
+
+DOCUMENTE_API_URL = environ.get("DOCUMENTE_API_URL")
+DOCUMENTE_API_KEY = environ.get("DOCUMENTE_API_KEY")
+
+DEFAULT_PAGINATION_PAGE_SIZE = 50

documente_shared-0.1.162/documente_shared/domain/entities/document_type.py

@@ -0,0 +1,49 @@
+from uuid import UUID
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+from documente_shared.domain.enums.processing_case import ProcessingDocumentType
+from documente_shared.domain.helpers.values import optional_str
+
+
+class DocumentType(BaseModel):
+    uuid: UUID
+    name: str
+    tenant_id: UUID | None = Field(default=None)
+    is_shareable: bool = False
+    processing_document_type: ProcessingDocumentType | None = Field(default=None)
+    metadata: dict | None = Field(default=None)
+    created_at: datetime | None = Field(default=None)
+    updated_at: datetime | None = Field(default=None)
+
+    @property
+    def to_persist_dict(self) -> dict:
+        return {
+            "tenant_id": self.tenant_id,
+            "name": self.name,
+            "is_shareable": self.is_shareable,
+            "processing_document_type": optional_str(self.processing_document_type),
+            "metadata": self.metadata or {},
+        }
+
+    @property
+    def to_dict(self) -> dict:
+        return {
+            "uuid": str(self.uuid),
+            "name": self.name,
+            "tenant_id": self
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'DocumentType':
+        return cls(
+            uuid=data.get('uuid'),
+            name=data.get('name'),
+            tenant_id=data.get('tenant_id'),
+            is_shareable=data.get('is_shareable', False),
+            processing_document_type=ProcessingDocumentType.from_value(data.get('processing_document_type')),
+            metadata=data.get('metadata', {}),
+            created_at=data.get('created_at'),
+            updated_at=data.get('updated_at'),
+        )

{documente_shared-0.1.161b5 → documente_shared-0.1.162}/documente_shared/domain/entities/workspace.py

@@ -1,30 +1,30 @@
-from dataclasses import dataclass
 from datetime import datetime
-from typing import Optional
 from uuid import UUID
 
+from pydantic import BaseModel, Field
+
 from documente_shared.application.time_utils import get_datetime_from_data
+from documente_shared.domain.entities.document_type import DocumentType
+from documente_shared.domain.helpers.values import optional_datetime_str
+
 
 
-@dataclass
-class Workspace(object):
+class Workspace(BaseModel):
     uuid: UUID
     name: str
-    tenant_slug: str
+    tenant_id: UUID | None = Field(default=None)
+    tenant_slug: str | None = Field(default=None)
     is_archived: bool = False
-    metadata: Optional[dict] = None
-    created_at: Optional[datetime] = None
-    updated_at: Optional[datetime] = None
-    document_types: Optional[list] = None
+    metadata: dict | None = Field(default_factory=dict)
+    created_at: datetime | None = Field(default=None)
+    updated_at: datetime | None = Field(default=None)
+    document_types: list[DocumentType] | None = Field(default_factory=list)
 
-    def __post_init__(self):
-        self.metadata = self.metadata or {}
-        self.document_types = self.document_types or []
 
     @property
     def to_persist_dict(self) -> dict:
         return {
-            "tenant_slug": self.tenant_slug,
+            "tenant_id": self.tenant_id,
             "name": self.name,
             "is_archived": self.is_archived,
             "metadata": self.metadata or {},
@@ -35,29 +35,29 @@ class Workspace(object):
         return {
             "uuid": str(self.uuid),
             "name": self.name,
+            "tenant_id": self.tenant_id,
             "tenant_slug": self.tenant_slug,
             "is_archived": self.is_archived,
             "metadata": self.metadata,
-            "created_at": (
-                self.created_at.isoformat()
-                if self.created_at else None
-            ),
-            "updated_at": (
-                self.updated_at.isoformat()
-                if self.updated_at else None
-            ),
-            "document_types": self.document_types,
+            "created_at": optional_datetime_str(self.created_at),
+            "updated_at": optional_datetime_str(self.updated_at),
+            "document_types": [dt.to_dict for dt in self.document_types] if self.document_types else [],
         }
 
     @classmethod
     def from_dict(cls, data: dict) -> 'Workspace':
+        document_types = data.get('document_types', [])
         return cls(
             uuid=data.get('uuid'),
             name=data.get('name'),
+            tenant_id=data.get('tenant_id'),
             tenant_slug=data.get('tenant_slug'),
             is_archived=data.get('is_archived', False),
             metadata=data.get('metadata', {}),
             created_at=get_datetime_from_data(input_datetime=data.get('created_at')),
             updated_at=get_datetime_from_data(input_datetime=data.get('updated_at')),
-            document_types=data.get('document_types', []),
+            document_types=[
+                DocumentType.from_dict(dt) 
+                for dt in document_types 
+            ],   
         )

documente_shared-0.1.162/documente_shared/domain/entities/workspace_document.py

@@ -0,0 +1,116 @@
+from dataclasses import Field, dataclass
+from datetime import datetime
+from decimal import Decimal
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+from documente_shared.application.time_utils import get_datetime_from_data
+from documente_shared.domain.entities.in_memory_document import InMemoryDocument
+from documente_shared.domain.enums.common import ProcessingStatus
+from documente_shared.domain.enums.workspace import WorkspaceSource
+from documente_shared.domain.helpers.values import optional_str
+
+
+class WorkspaceDocument(BaseModel):
+    uuid: UUID
+    name: str
+    status: ProcessingStatus
+    workspace_id: UUID
+    tenant_id: UUID | None = Field(default=None)
+    tenant_slug: str | None = Field(default=None)
+    digest: str | None = Field(default=None)
+    document_type_id: UUID | None = Field(default=None)
+    source: WorkspaceSource | None = Field(default=None)
+    document: InMemoryDocument | None = Field(default=None)
+    document_url: str | None = Field(default=None)
+    processing_time: Decimal | None = Field(default=None)
+    metadata: dict | None = Field(default_factory=dict)
+    extraction: dict | None = Field(default_factory=dict)
+    uploaded_at: datetime | None = Field(default=None)
+    created_at: datetime | None = Field(default=None)
+    updated_at: datetime | None = Field(default=None)
+    started_at: datetime | None = Field(default=None)
+    completed_at: datetime | None = Field(default=None)
+    failed_at: datetime | None = Field(default=None)
+
+
+    @property
+    def to_persist_dict(self) -> dict:
+        return {
+            "tenant_id": self.tenant_id,
+            "workspace_id": str(self.workspace_id),
+            "document_type_id": optional_str(self.document_type_id),
+            "name": self.name,
+            "digest": self.digest,
+            "status": str(self.status),
+            "source": optional_str(self.source),
+            "uploaded_at": self.uploaded_at,
+            "started_at": self.started_at,
+            "completed_at": self.completed_at,
+            "failed_at": self.failed_at,
+            "processing_time": self.processing_time,
+            "metadata": self.metadata or {},
+            "extraction": self.extraction or {},
+        }
+
+    @property
+    def to_dict(self) -> dict:
+        return {
+            "uuid": str(self.uuid),
+            "name": self.name,
+            "digest": self.digest,
+            "status": str(self.status),
+            "tenant_id": self.tenant_id,
+            "tenant_slug": self.tenant_slug,
+            "workspace_id": str(self.workspace_id),
+            "document_type_id": optional_str(self.document_type_id),
+            "source": optional_str(self.source),
+            "document": (self.document.to_dict if self.document else None),
+            "document_url": self.document_url,
+            "processing_time": optional_str(self.processing_time),
+            "metadata": self.metadata,
+            "extraction": self.extraction,
+            "uploaded_at": (self.uploaded_at.isoformat() if self.uploaded_at else None),
+            "created_at": (self.created_at.isoformat() if self.created_at else None),
+            "updated_at": (self.updated_at.isoformat() if self.updated_at else None),
+            "started_at": (self.started_at.isoformat() if self.started_at else None),
+            "completed_at": (
+                self.completed_at.isoformat() if self.completed_at else None
+            ),
+            "failed_at": (self.failed_at.isoformat() if self.failed_at else None),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "WorkspaceDocument":
+        return cls(
+            uuid=data.get("uuid"),
+            name=data.get("name"),
+            digest=data.get("digest"),
+            status=ProcessingStatus.from_value(data.get("status")),
+            tenant_slug=data.get("tenant_slug"),
+            workspace_id=data.get("workspace_id"),
+            document_type_id=data.get("document_type_id"),
+            source=WorkspaceSource.from_value(data.get("source")),
+            document=(
+                InMemoryDocument.from_dict(data.get("document"))
+                if data.get("document")
+                else None
+            ),
+            document_url=data.get("document_url"),
+            processing_time=(
+                Decimal(data.get("processing_time"))
+                if data.get("processing_time")
+                else None
+            ),
+            metadata=data.get("metadata", {}),
+            extraction=data.get("extraction", {}),
+            uploaded_at=get_datetime_from_data(input_datetime=data.get("uploaded_at")),
+            created_at=get_datetime_from_data(input_datetime=data.get("created_at")),
+            updated_at=get_datetime_from_data(input_datetime=data.get("updated_at")),
+            started_at=get_datetime_from_data(input_datetime=data.get("started_at")),
+            completed_at=get_datetime_from_data(
+                input_datetime=data.get("completed_at")
+            ),
+            failed_at=get_datetime_from_data(input_datetime=data.get("failed_at")),
+        )

{documente_shared-0.1.161b5 → documente_shared-0.1.162}/documente_shared/domain/entities/workspace_document_page.py

@@ -1,28 +1,29 @@
-from dataclasses import dataclass
 from datetime import datetime
-from typing import Optional
 from uuid import UUID
 
+from pydantic import BaseModel, Field
+
 from documente_shared.application.time_utils import get_datetime_from_data
 from documente_shared.domain.entities.in_memory_document import InMemoryDocument
 
 
-@dataclass
-class WorkspaceDocumentPage(object):
+
+class WorkspaceDocumentPage(BaseModel):
     uuid: UUID
-    tenant_slug: str
     workspace_id: UUID
     workspace_document_id: UUID
     page_number: int
-    page_file: Optional[InMemoryDocument] = None
-    page_file_url: Optional[str] = None
-    created_at: Optional[datetime] = None
-    synced_at: Optional[datetime] = None
+    tenant_id: UUID | None = Field(default=None)
+    tenant_slug: str | None = Field(default=None)
+    page_file: InMemoryDocument | None = Field(default=None)
+    page_file_url: str | None = Field(default=None)
+    created_at: datetime | None = Field(default=None)
+    synced_at: datetime | None = Field(default=None)
 
     @property
     def to_persist_dict(self) -> dict:
         return {
-            "tenant_slug": self.tenant_slug,
+            "tenant_id": self.tenant_id,
             "workspace_id": str(self.workspace_id),
             "workspace_document_id": str(self.workspace_document_id),
             "page_number": self.page_number,
@@ -33,6 +34,7 @@ class WorkspaceDocumentPage(object):
     def to_dict(self) -> dict:
         return {
             "uuid": str(self.uuid),
+            "tenant_id": self.tenant_id,
             "tenant_slug": self.tenant_slug,
             "workspace_id": str(self.workspace_id),
             "workspace_document_id": str(self.workspace_document_id),
@@ -56,6 +58,7 @@ class WorkspaceDocumentPage(object):
     def from_dict(cls, data: dict) -> 'WorkspaceDocumentPage':
         return cls(
             uuid=data.get('uuid'),
+            tenant_id=data.get('tenant_id'),
             tenant_slug=data.get('tenant_slug'),
             workspace_id=data.get('workspace_id'),
             workspace_document_id=data.get('workspace_document_id'),

{documente_shared-0.1.161b5 → documente_shared-0.1.162}/documente_shared/domain/entities/workspace_filters.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass
 from typing import Optional
 
 from documente_shared.application.query_params import QueryParams
+from documente_shared.domain.helpers.dicts import filter_none_values
 
 
 @dataclass
@@ -20,7 +21,7 @@ class WorkspaceFilters(object):
             "search": self.search,
             "include_archived": str(self.include_archived).lower(),
         }
-        return {k: v for k, v in params.items() if v is not None}
+        return filter_none_values(params)
 
     @classmethod
     def from_params(cls, params: QueryParams) -> "WorkspaceFilters":

documente_shared-0.1.162/documente_shared/domain/filters/document_type.py

@@ -0,0 +1,24 @@
+from uuid import UUID
+from pydantic import Field
+
+from documente_shared.application.query_params import QueryParams
+from documente_shared.domain.helpers.dicts import filter_none_values
+from documente_shared.domain.pagination.entities import ListFilters
+
+
+class DocumentTypeFilters(ListFilters):
+    tenant_ids: list[UUID] | None = Field(default_factory=list)
+
+    @property
+    def to_params(self) -> dict:
+        return filter_none_values({
+            **super().to_dict,
+            "tenant_ids": self.tenant_ids,
+        })
+
+    @classmethod
+    def from_params(cls, params: QueryParams) -> "DocumentTypeFilters":
+        return cls(
+            cursor=params.get("cursor", None),
+            limit=params.get_int(key="limit", default=None),
+        )

documente_shared-0.1.162/documente_shared/domain/filters/workspace.py

@@ -0,0 +1,28 @@
+from uuid import UUID
+from pydantic import Field
+
+from documente_shared.application.query_params import QueryParams
+from documente_shared.domain.helpers.dicts import filter_none_values
+from documente_shared.domain.pagination.entities import ListFilters
+
+
+class WorkspaceFilters(ListFilters):
+    tenant_ids: list[UUID] | None = Field(default_factory=list)
+    search: str | None = Field(default=None)
+
+    @property
+    def to_params(self) -> dict:
+        return filter_none_values({
+            **super().to_dict,
+            "tenant_ids": self.tenant_ids,
+            "search": self.search,
+        })
+
+    @classmethod
+    def from_params(cls, params: QueryParams) -> "WorkspaceFilters":
+        search_term = params.get_str(key="search", default=None)
+        return cls(
+            cursor=params.get("cursor", None),
+            limit=params.get_int(key="limit", default=None),
+            search=search_term.strip() if search_term else None,
+        )

documente_shared-0.1.162/documente_shared/domain/filters/workspace_document.py

@@ -0,0 +1,46 @@
+from uuid import UUID
+from pydantic import Field
+
+from documente_shared.application.query_params import QueryParams
+from documente_shared.domain.enums.common import ProcessingStatus
+from documente_shared.domain.helpers.dicts import filter_none_values
+from documente_shared.domain.helpers.lists import enum_list_to_comma_string
+from documente_shared.domain.pagination.entities import ListFilters
+
+
+class WorkspaceDocumentFilters(ListFilters):
+    workspace_id: UUID | None = Field(default=None)
+    tenant_ids: list[UUID] | None = Field(default_factory=list)
+    workspace_ids: list[UUID] | None = Field(default_factory=list)
+    statuses: list[ProcessingStatus] | None = Field(default_factory=list)
+    search: str | None = Field(default=None)
+    digest: str | None = Field(default=None)
+
+    @property
+    def to_params(self) -> dict:
+        return filter_none_values({
+            **super().to_dict,
+            "tenant_ids": self.tenant_ids,
+            "workspace_ids": self.workspace_ids,
+            "search": self.search,
+            "digest": self.digest,
+            "statuses": enum_list_to_comma_string(self.statuses),
+        })
+
+    @classmethod
+    def from_params(cls, params: QueryParams) -> "WorkspaceDocumentFilters":
+        search_term = params.get_str(key="search", default=None)
+        return cls(
+            cursor=params.get("cursor", None),
+            limit=params.get_int(key="limit", default=None),
+            workspace_id=params.get_uuid(key="workspace_id", default=None),
+            tenant_ids=params.get_uuid_list(key="tenant_ids", default=None),
+            workspace_ids=params.get_uuid_list(key="workspace_ids", default=None),
+            search=search_term.strip() if search_term else None,
+            digest=params.get_str(key="digest", default=None),
+            statuses=params.get_enum_list(
+                key="statuses",
+                enum_class=ProcessingStatus,
+                default=None,
+            ),
+        )

documente_shared-0.1.162/documente_shared/domain/filters/workspace_document_page.py

@@ -0,0 +1,27 @@
+from uuid import UUID
+
+from pydantic import Field
+
+from documente_shared.application.query_params import QueryParams
+from documente_shared.domain.helpers.dicts import filter_none_values
+from documente_shared.domain.helpers.values import optional_str
+from documente_shared.domain.pagination.entities import ListFilters
+
+
+class WorkspaceDocumentPageFilters(ListFilters):
+    workspace_document_id: UUID | None = Field(default=None)
+
+    @property
+    def to_params(self) -> dict:
+        return filter_none_values({
+            **super().to_dict,
+            "workspace_document_id": optional_str(self.workspace_document_id),
+        })
+
+    @classmethod
+    def from_params(cls, params: QueryParams) -> "WorkspaceDocumentPageFilters":
+        return cls(
+            cursor=params.get("cursor", None),
+            limit=params.get_int(key="limit", default=None),
+            workspace_document_id=params.get_uuid(key="workspace_document_id", default=None),
+        )