llama-cloud 0.1.41__py3-none-any.whl → 1.0.0b4__py3-none-any.whl

llama_cloud/types/beta/split_result_response.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ..._models import BaseModel
+from .split_segment_response import SplitSegmentResponse
+
+__all__ = ["SplitResultResponse"]
+
+
+class SplitResultResponse(BaseModel):
+    """Result of a completed split job."""
+
+    segments: List[SplitSegmentResponse]
+    """List of document segments."""

llama_cloud/types/beta/split_segment_response.py

@@ -0,0 +1,20 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ..._models import BaseModel
+
+__all__ = ["SplitSegmentResponse"]
+
+
+class SplitSegmentResponse(BaseModel):
+    """A segment of the split document."""
+
+    category: str
+    """Category name this split belongs to."""
+
+    confidence_category: str
+    """Categorical confidence level. Valid values are: high, medium, low."""
+
+    pages: List[int]
+    """1-indexed page numbers in this split."""

llama_cloud/types/classifier/__init__.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .classify_job import ClassifyJob as ClassifyJob
+from .job_get_params import JobGetParams as JobGetParams
+from .classifier_rule import ClassifierRule as ClassifierRule
+from .job_list_params import JobListParams as JobListParams
+from .job_create_params import JobCreateParams as JobCreateParams
+from .classify_job_param import ClassifyJobParam as ClassifyJobParam
+from .classifier_rule_param import ClassifierRuleParam as ClassifierRuleParam
+from .job_get_results_params import JobGetResultsParams as JobGetResultsParams
+from .job_get_results_response import JobGetResultsResponse as JobGetResultsResponse
+from .classify_parsing_configuration import ClassifyParsingConfiguration as ClassifyParsingConfiguration
+from .classify_parsing_configuration_param import ClassifyParsingConfigurationParam as ClassifyParsingConfigurationParam

llama_cloud/types/classifier/classifier_rule.py

@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+
+__all__ = ["ClassifierRule"]
+
+
+class ClassifierRule(BaseModel):
+    """A rule for classifying documents - v0 simplified version.
+
+    This represents a single classification rule that will be applied to documents.
+    All rules are content-based and use natural language descriptions.
+    """
+
+    description: str
+    """Natural language description of what to classify.
+
+    Be specific about the content characteristics that identify this document type.
+    """
+
+    type: str
+    """
+    The document type to assign when this rule matches (e.g., 'invoice', 'receipt',
+    'contract')
+    """

llama_cloud/types/classifier/classifier_rule_param.py

@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["ClassifierRuleParam"]
+
+
+class ClassifierRuleParam(TypedDict, total=False):
+    """A rule for classifying documents - v0 simplified version.
+
+    This represents a single classification rule that will be applied to documents.
+    All rules are content-based and use natural language descriptions.
+    """
+
+    description: Required[str]
+    """Natural language description of what to classify.
+
+    Be specific about the content characteristics that identify this document type.
+    """
+
+    type: Required[str]
+    """
+    The document type to assign when this rule matches (e.g., 'invoice', 'receipt',
+    'contract')
+    """

llama_cloud/types/classifier/classify_job.py

@@ -0,0 +1,51 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from ..status_enum import StatusEnum
+from .classifier_rule import ClassifierRule
+from .classify_parsing_configuration import ClassifyParsingConfiguration
+
+__all__ = ["ClassifyJob"]
+
+
+class ClassifyJob(BaseModel):
+    """A classify job."""
+
+    id: str
+    """Unique identifier"""
+
+    project_id: str
+    """The ID of the project"""
+
+    rules: List[ClassifierRule]
+    """The rules to classify the files"""
+
+    status: StatusEnum
+    """The status of the classify job"""
+
+    user_id: str
+    """The ID of the user"""
+
+    created_at: Optional[datetime] = None
+    """Creation datetime"""
+
+    effective_at: Optional[datetime] = None
+
+    error_message: Optional[str] = None
+    """Error message for the latest job attempt, if any."""
+
+    job_record_id: Optional[str] = None
+    """The job record ID associated with this status, if any."""
+
+    mode: Optional[Literal["FAST", "MULTIMODAL"]] = None
+    """The classification mode to use"""
+
+    parsing_configuration: Optional[ClassifyParsingConfiguration] = None
+    """The configuration for the parsing job"""
+
+    updated_at: Optional[datetime] = None
+    """Update datetime"""

llama_cloud/types/classifier/classify_job_param.py

@@ -0,0 +1,53 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable, Optional
+from datetime import datetime
+from typing_extensions import Literal, Required, Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+from ..status_enum import StatusEnum
+from .classifier_rule_param import ClassifierRuleParam
+from .classify_parsing_configuration_param import ClassifyParsingConfigurationParam
+
+__all__ = ["ClassifyJobParam"]
+
+
+class ClassifyJobParam(TypedDict, total=False):
+    """A classify job."""
+
+    id: Required[str]
+    """Unique identifier"""
+
+    project_id: Required[str]
+    """The ID of the project"""
+
+    rules: Required[Iterable[ClassifierRuleParam]]
+    """The rules to classify the files"""
+
+    status: Required[StatusEnum]
+    """The status of the classify job"""
+
+    user_id: Required[str]
+    """The ID of the user"""
+
+    created_at: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Creation datetime"""
+
+    effective_at: Annotated[Union[str, datetime], PropertyInfo(format="iso8601")]
+
+    error_message: Optional[str]
+    """Error message for the latest job attempt, if any."""
+
+    job_record_id: Optional[str]
+    """The job record ID associated with this status, if any."""
+
+    mode: Literal["FAST", "MULTIMODAL"]
+    """The classification mode to use"""
+
+    parsing_configuration: ClassifyParsingConfigurationParam
+    """The configuration for the parsing job"""
+
+    updated_at: Annotated[Union[str, datetime, None], PropertyInfo(format="iso8601")]
+    """Update datetime"""

llama_cloud/types/classifier/classify_parsing_configuration.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+from ..parsing_languages import ParsingLanguages
+
+__all__ = ["ClassifyParsingConfiguration"]
+
+
+class ClassifyParsingConfiguration(BaseModel):
+    """Parsing configuration for a classify job."""
+
+    lang: Optional[ParsingLanguages] = None
+    """The language to parse the files in"""
+
+    max_pages: Optional[int] = None
+    """The maximum number of pages to parse"""
+
+    target_pages: Optional[List[int]] = None
+    """The pages to target for parsing (0-indexed, so first page is at 0)"""

llama_cloud/types/classifier/classify_parsing_configuration_param.py

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+from typing_extensions import TypedDict
+
+from ..parsing_languages import ParsingLanguages
+
+__all__ = ["ClassifyParsingConfigurationParam"]
+
+
+class ClassifyParsingConfigurationParam(TypedDict, total=False):
+    """Parsing configuration for a classify job."""
+
+    lang: ParsingLanguages
+    """The language to parse the files in"""
+
+    max_pages: Optional[int]
+    """The maximum number of pages to parse"""
+
+    target_pages: Optional[Iterable[int]]
+    """The pages to target for parsing (0-indexed, so first page is at 0)"""

llama_cloud/types/classifier/job_create_params.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable, Optional
+from typing_extensions import Literal, Required, TypedDict
+
+from ..._types import SequenceNotStr
+from .classifier_rule_param import ClassifierRuleParam
+from .classify_parsing_configuration_param import ClassifyParsingConfigurationParam
+
+__all__ = ["JobCreateParams"]
+
+
+class JobCreateParams(TypedDict, total=False):
+    file_ids: Required[SequenceNotStr[str]]
+    """The IDs of the files to classify"""
+
+    rules: Required[Iterable[ClassifierRuleParam]]
+    """The rules to classify the files"""
+
+    organization_id: Optional[str]
+
+    project_id: Optional[str]
+
+    mode: Literal["FAST", "MULTIMODAL"]
+    """The classification mode to use"""
+
+    parsing_configuration: ClassifyParsingConfigurationParam
+    """The configuration for the parsing job"""

llama_cloud/types/classifier/job_get_params.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+__all__ = ["JobGetParams"]
+
+
+class JobGetParams(TypedDict, total=False):
+    organization_id: Optional[str]
+
+    project_id: Optional[str]

llama_cloud/types/classifier/job_get_results_params.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+__all__ = ["JobGetResultsParams"]
+
+
+class JobGetResultsParams(TypedDict, total=False):
+    organization_id: Optional[str]
+
+    project_id: Optional[str]

llama_cloud/types/classifier/job_get_results_response.py

@@ -0,0 +1,66 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from datetime import datetime
+
+from ..._models import BaseModel
+
+__all__ = ["JobGetResultsResponse", "Item", "ItemResult"]
+
+
+class ItemResult(BaseModel):
+    """Result of classifying a single file."""
+
+    confidence: float
+    """Confidence score of the classification (0.0-1.0)"""
+
+    reasoning: str
+    """
+    Step-by-step explanation of why this classification was chosen and the
+    confidence score assigned
+    """
+
+    type: Optional[str] = None
+    """The document type that best matches, or null if no match."""
+
+
+class Item(BaseModel):
+    """A file classification."""
+
+    id: str
+    """Unique identifier"""
+
+    classify_job_id: str
+    """The ID of the classify job"""
+
+    created_at: Optional[datetime] = None
+    """Creation datetime"""
+
+    file_id: Optional[str] = None
+    """The ID of the classified file"""
+
+    result: Optional[ItemResult] = None
+    """Result of classifying a single file."""
+
+    updated_at: Optional[datetime] = None
+    """Update datetime"""
+
+
+class JobGetResultsResponse(BaseModel):
+    """Response model for the classify endpoint following AIP-132 pagination standard."""
+
+    items: List[Item]
+    """The list of items."""
+
+    next_page_token: Optional[str] = None
+    """A token, which can be sent as page_token to retrieve the next page.
+
+    If this field is omitted, there are no subsequent pages.
+    """
+
+    total_size: Optional[int] = None
+    """The total number of items available.
+
+    This is only populated when specifically requested. The value may be an estimate
+    and can be used for display purposes only.
+    """

llama_cloud/types/classifier/job_list_params.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import TypedDict
+
+__all__ = ["JobListParams"]
+
+
+class JobListParams(TypedDict, total=False):
+    organization_id: Optional[str]
+
+    page_size: Optional[int]
+
+    page_token: Optional[str]
+
+    project_id: Optional[str]

llama_cloud/types/cohere_embedding.py

@@ -1,40 +1,37 @@
-# This file was auto-generated by Fern from our API Definition.
-
-import datetime as dt
-import typing
-
-from ..core.datetime_utils import serialize_datetime
-
-try:
-    import pydantic
-    if pydantic.__version__.startswith("1."):
-        raise ImportError
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
-
-
-class CohereEmbedding(pydantic.BaseModel):
-    model_name: typing.Optional[str] = pydantic.Field(description="The modelId of the Cohere model to use.")
-    embed_batch_size: typing.Optional[int] = pydantic.Field(description="The batch size for embedding calls.")
-    num_workers: typing.Optional[int]
-    api_key: typing.Optional[str]
-    truncate: typing.Optional[str] = pydantic.Field(description="Truncation type - START/ END/ NONE")
-    input_type: typing.Optional[str]
-    embedding_type: typing.Optional[str] = pydantic.Field(
-        description="Embedding type. If not provided float embedding_type is used when needed."
-    )
-    class_name: typing.Optional[str]
-
-    def json(self, **kwargs: typing.Any) -> str:
-        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
-        return super().json(**kwargs_with_defaults)
-
-    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
-        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
-        return super().dict(**kwargs_with_defaults)
-
-    class Config:
-        frozen = True
-        smart_union = True
-        json_encoders = {dt.datetime: serialize_datetime}
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["CohereEmbedding"]
+
+
+class CohereEmbedding(BaseModel):
+    api_key: Optional[str] = None
+    """The Cohere API key."""
+
+    class_name: Optional[str] = None
+
+    embed_batch_size: Optional[int] = None
+    """The batch size for embedding calls."""
+
+    embedding_type: Optional[str] = None
+    """Embedding type. If not provided float embedding_type is used when needed."""
+
+    input_type: Optional[str] = None
+    """Model Input type.
+
+    If not provided, search_document and search_query are used when needed.
+    """
+
+    api_model_name: Optional[str] = FieldInfo(alias="model_name", default=None)
+    """The modelId of the Cohere model to use."""
+
+    num_workers: Optional[int] = None
+    """The number of workers to use for async embedding calls."""
+
+    truncate: Optional[str] = None
+    """Truncation type - START/ END/ NONE"""

llama_cloud/types/cohere_embedding_config.py

@@ -1,34 +1,17 @@
-# This file was auto-generated by Fern from our API Definition.
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import datetime as dt
-import typing
+from typing import Optional
+from typing_extensions import Literal
 
-from ..core.datetime_utils import serialize_datetime
+from .._models import BaseModel
 from .cohere_embedding import CohereEmbedding
 
-try:
-    import pydantic
-    if pydantic.__version__.startswith("1."):
-        raise ImportError
-    import pydantic.v1 as pydantic  # type: ignore
-except ImportError:
-    import pydantic  # type: ignore
+__all__ = ["CohereEmbeddingConfig"]
 
 
-class CohereEmbeddingConfig(pydantic.BaseModel):
-    component: typing.Optional[CohereEmbedding] = pydantic.Field(
-        description="Configuration for the Cohere embedding model."
-    )
+class CohereEmbeddingConfig(BaseModel):
+    component: Optional[CohereEmbedding] = None
+    """Configuration for the Cohere embedding model."""
 
-    def json(self, **kwargs: typing.Any) -> str:
-        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
-        return super().json(**kwargs_with_defaults)
-
-    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
-        kwargs_with_defaults: typing.Any = {"by_alias": True, "exclude_unset": True, **kwargs}
-        return super().dict(**kwargs_with_defaults)
-
-    class Config:
-        frozen = True
-        smart_union = True
-        json_encoders = {dt.datetime: serialize_datetime}
+    type: Optional[Literal["COHERE_EMBEDDING"]] = None
+    """Type of the embedding model."""

llama_cloud/types/cohere_embedding_config_param.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+from .cohere_embedding_param import CohereEmbeddingParam
+
+__all__ = ["CohereEmbeddingConfigParam"]
+
+
+class CohereEmbeddingConfigParam(TypedDict, total=False):
+    component: CohereEmbeddingParam
+    """Configuration for the Cohere embedding model."""
+
+    type: Literal["COHERE_EMBEDDING"]
+    """Type of the embedding model."""

llama_cloud/types/cohere_embedding_param.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Required, TypedDict
+
+__all__ = ["CohereEmbeddingParam"]
+
+
+class CohereEmbeddingParam(TypedDict, total=False):
+    api_key: Required[Optional[str]]
+    """The Cohere API key."""
+
+    class_name: str
+
+    embed_batch_size: int
+    """The batch size for embedding calls."""
+
+    embedding_type: str
+    """Embedding type. If not provided float embedding_type is used when needed."""
+
+    input_type: Optional[str]
+    """Model Input type.
+
+    If not provided, search_document and search_query are used when needed.
+    """
+
+    model_name: str
+    """The modelId of the Cohere model to use."""
+
+    num_workers: Optional[int]
+    """The number of workers to use for async embedding calls."""
+
+    truncate: str
+    """Truncation type - START/ END/ NONE"""

llama_cloud/types/composite_retrieval_mode.py

@@ -1,21 +1,7 @@
-# This file was auto-generated by Fern from our API Definition.
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import enum
-import typing
+from typing_extensions import Literal, TypeAlias
 
-T_Result = typing.TypeVar("T_Result")
+__all__ = ["CompositeRetrievalMode"]
 
-
-class CompositeRetrievalMode(str, enum.Enum):
-    """
-    Enum for the mode of composite retrieval.
-    """
-
-    ROUTING = "routing"
-    FULL = "full"
-
-    def visit(self, routing: typing.Callable[[], T_Result], full: typing.Callable[[], T_Result]) -> T_Result:
-        if self is CompositeRetrievalMode.ROUTING:
-            return routing()
-        if self is CompositeRetrievalMode.FULL:
-            return full()
+CompositeRetrievalMode: TypeAlias = Literal["routing", "full"]