casedev 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

casedev/types/vault_retrieve_response.py

@@ -0,0 +1,76 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from datetime import datetime
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["VaultRetrieveResponse", "ChunkStrategy"]
+
+
+class ChunkStrategy(BaseModel):
+    """Document chunking strategy configuration"""
+
+    chunk_size: Optional[int] = FieldInfo(alias="chunkSize", default=None)
+    """Target size for each chunk in tokens"""
+
+    method: Optional[str] = None
+    """Chunking method (e.g., 'semantic', 'fixed')"""
+
+    min_chunk_size: Optional[int] = FieldInfo(alias="minChunkSize", default=None)
+    """Minimum chunk size in tokens"""
+
+    overlap: Optional[int] = None
+    """Number of overlapping tokens between chunks"""
+
+
+class VaultRetrieveResponse(BaseModel):
+    id: Optional[str] = None
+    """Vault identifier"""
+
+    chunk_strategy: Optional[ChunkStrategy] = FieldInfo(alias="chunkStrategy", default=None)
+    """Document chunking strategy configuration"""
+
+    created_at: Optional[datetime] = FieldInfo(alias="createdAt", default=None)
+    """Vault creation timestamp"""
+
+    description: Optional[str] = None
+    """Vault description"""
+
+    enable_graph: Optional[bool] = FieldInfo(alias="enableGraph", default=None)
+    """Whether GraphRAG is enabled"""
+
+    files_bucket: Optional[str] = FieldInfo(alias="filesBucket", default=None)
+    """S3 bucket for document storage"""
+
+    index_name: Optional[str] = FieldInfo(alias="indexName", default=None)
+    """Search index name"""
+
+    kms_key_id: Optional[str] = FieldInfo(alias="kmsKeyId", default=None)
+    """KMS key for encryption"""
+
+    metadata: Optional[object] = None
+    """Additional vault metadata"""
+
+    name: Optional[str] = None
+    """Vault name"""
+
+    region: Optional[str] = None
+    """AWS region"""
+
+    total_bytes: Optional[int] = FieldInfo(alias="totalBytes", default=None)
+    """Total storage size in bytes"""
+
+    total_objects: Optional[int] = FieldInfo(alias="totalObjects", default=None)
+    """Number of stored documents"""
+
+    total_vectors: Optional[int] = FieldInfo(alias="totalVectors", default=None)
+    """Number of vector embeddings"""
+
+    updated_at: Optional[datetime] = FieldInfo(alias="updatedAt", default=None)
+    """Last update timestamp"""
+
+    vector_bucket: Optional[str] = FieldInfo(alias="vectorBucket", default=None)
+    """S3 bucket for vector embeddings"""

casedev/types/vault_search_params.py

@@ -2,20 +2,21 @@
 
 from __future__ import annotations
 
-from typing import Dict
-from typing_extensions import Literal, Required, Annotated, TypedDict
+from typing import Dict, Union
+from typing_extensions import Literal, Required, Annotated, TypeAlias, TypedDict
 
+from .._types import SequenceNotStr
 from .._utils import PropertyInfo
 
-__all__ = ["VaultSearchParams"]
+__all__ = ["VaultSearchParams", "Filters"]
 
 
 class VaultSearchParams(TypedDict, total=False):
     query: Required[str]
     """Search query or question to find relevant documents"""
 
-    filters: Dict[str, object]
-    """Additional filters to apply to search results"""
+    filters: Filters
+    """Filters to narrow search results to specific documents"""
 
     method: Literal["vector", "graph", "hybrid", "global", "local", "fast", "entity"]
     """
@@ -25,3 +26,16 @@ class VaultSearchParams(TypedDict, total=False):
 
     top_k: Annotated[int, PropertyInfo(alias="topK")]
     """Maximum number of results to return"""
+
+
+class FiltersTyped(TypedDict, total=False):
+    """Filters to narrow search results to specific documents"""
+
+    object_id: Union[str, SequenceNotStr[str]]
+    """Filter to specific document(s) by object ID.
+
+    Accepts a single ID or array of IDs.
+    """
+
+
+Filters: TypeAlias = Union[FiltersTyped, Dict[str, object]]

casedev/types/vault_search_response.py

@@ -11,11 +11,35 @@ __all__ = ["VaultSearchResponse", "Chunk", "Source"]
 
 
 class Chunk(BaseModel):
+    chunk_index: Optional[int] = None
+    """Index of the chunk within the document (0-based)"""
+
+    distance: Optional[float] = None
+    """Vector similarity distance (lower is more similar)"""
+
+    object_id: Optional[str] = None
+    """ID of the source document"""
+
+    page_end: Optional[int] = None
+    """PDF page number where the chunk ends (1-indexed).
+
+    Null for non-PDF documents or documents ingested before page tracking was added.
+    """
+
+    page_start: Optional[int] = None
+    """PDF page number where the chunk begins (1-indexed).
+
+    Null for non-PDF documents or documents ingested before page tracking was added.
+    """
+
     score: Optional[float] = None
+    """Relevance score (deprecated, use distance or hybridScore)"""
 
     source: Optional[str] = None
+    """Source identifier (deprecated, use object_id)"""
 
     text: Optional[str] = None
+    """Preview of the chunk text (up to 500 characters)"""
 
 
 class Source(BaseModel):
@@ -36,7 +60,7 @@ class Source(BaseModel):
 
 class VaultSearchResponse(BaseModel):
     chunks: Optional[List[Chunk]] = None
-    """Relevant text chunks with similarity scores"""
+    """Relevant text chunks with similarity scores and page locations"""
 
     method: Optional[str] = None
     """Search method used"""

casedev/types/vault_upload_params.py

@@ -22,5 +22,12 @@ class VaultUploadParams(TypedDict, total=False):
     metadata: object
     """Additional metadata to associate with the file"""
 
+    path: str
+    """Optional folder path for hierarchy preservation.
+
+    Allows integrations to maintain source folder structure from systems like
+    NetDocs, Clio, or Smokeball. Example: '/Discovery/Depositions/2024'
+    """
+
     size_bytes: Annotated[float, PropertyInfo(alias="sizeBytes")]
     """Estimated file size in bytes for cost calculation"""

casedev/types/vault_upload_response.py

@@ -21,6 +21,9 @@ class VaultUploadResponse(BaseModel):
     auto_index: Optional[bool] = None
     """Whether the file will be automatically indexed"""
 
+    enable_indexing: Optional[bool] = FieldInfo(alias="enableIndexing", default=None)
+    """Whether the vault supports indexing. False for storage-only vaults."""
+
     expires_in: Optional[float] = FieldInfo(alias="expiresIn", default=None)
     """URL expiration time in seconds"""
 
@@ -32,6 +35,9 @@ class VaultUploadResponse(BaseModel):
     object_id: Optional[str] = FieldInfo(alias="objectId", default=None)
     """Unique identifier for the uploaded object"""
 
+    path: Optional[str] = None
+    """Folder path for hierarchy if provided"""
+
     s3_key: Optional[str] = FieldInfo(alias="s3Key", default=None)
     """S3 object key for the file"""
 

casedev/types/voice/__init__.py

@@ -3,5 +3,8 @@
 from __future__ import annotations
 
 from .v1_list_voices_params import V1ListVoicesParams as V1ListVoicesParams
+from .v1_list_voices_response import V1ListVoicesResponse as V1ListVoicesResponse
+from .streaming_get_url_response import StreamingGetURLResponse as StreamingGetURLResponse
 from .transcription_create_params import TranscriptionCreateParams as TranscriptionCreateParams
+from .transcription_create_response import TranscriptionCreateResponse as TranscriptionCreateResponse
 from .transcription_retrieve_response import TranscriptionRetrieveResponse as TranscriptionRetrieveResponse

casedev/types/voice/streaming_get_url_response.py

@@ -0,0 +1,44 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from ..._models import BaseModel
+
+__all__ = ["StreamingGetURLResponse", "AudioFormat", "Pricing"]
+
+
+class AudioFormat(BaseModel):
+    channels: Optional[int] = None
+    """Number of audio channels"""
+
+    encoding: Optional[str] = None
+    """Required audio encoding format"""
+
+    sample_rate: Optional[int] = None
+    """Required audio sample rate in Hz"""
+
+
+class Pricing(BaseModel):
+    currency: Optional[str] = None
+    """Currency for pricing"""
+
+    per_hour: Optional[float] = None
+    """Cost per hour of transcription"""
+
+    per_minute: Optional[float] = None
+    """Cost per minute of transcription"""
+
+
+class StreamingGetURLResponse(BaseModel):
+    audio_format: Optional[AudioFormat] = None
+
+    connect_url: Optional[str] = None
+    """Complete WebSocket URL with authentication token"""
+
+    pricing: Optional[Pricing] = None
+
+    protocol: Optional[str] = None
+    """Connection protocol"""
+
+    url: Optional[str] = None
+    """Base WebSocket URL for streaming transcription"""

casedev/types/voice/transcription_create_params.py

@@ -2,21 +2,29 @@
 
 from __future__ import annotations
 
-from typing_extensions import Required, TypedDict
+from typing_extensions import Literal, TypedDict
+
+from ..._types import SequenceNotStr
 
 __all__ = ["TranscriptionCreateParams"]
 
 
 class TranscriptionCreateParams(TypedDict, total=False):
-    audio_url: Required[str]
-    """URL of the audio file to transcribe"""
+    audio_url: str
+    """URL of the audio file to transcribe (legacy mode, no auto-storage)"""
 
     auto_highlights: bool
     """Automatically extract key phrases and topics"""
 
+    boost_param: Literal["low", "default", "high"]
+    """How much to boost custom vocabulary"""
+
     content_safety_labels: bool
     """Enable content moderation and safety labeling"""
 
+    format: Literal["json", "text"]
+    """Output format for the transcript when using vault mode"""
+
     format_text: bool
     """Format text with proper capitalization"""
 
@@ -29,8 +37,20 @@ class TranscriptionCreateParams(TypedDict, total=False):
     language_detection: bool
     """Enable automatic language detection"""
 
+    object_id: str
+    """Object ID of the audio file in the vault (use with vault_id)"""
+
     punctuate: bool
     """Add punctuation to the transcript"""
 
     speaker_labels: bool
     """Enable speaker identification and labeling"""
+
+    speakers_expected: int
+    """Expected number of speakers (improves accuracy when known)"""
+
+    vault_id: str
+    """Vault ID containing the audio file (use with object_id)"""
+
+    word_boost: SequenceNotStr[str]
+    """Custom vocabulary words to boost (e.g., legal terms)"""

casedev/types/voice/transcription_create_response.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["TranscriptionCreateResponse"]
+
+
+class TranscriptionCreateResponse(BaseModel):
+    id: Optional[str] = None
+    """Unique transcription job ID"""
+
+    source_object_id: Optional[str] = None
+    """Source audio object ID (only for vault-based transcription)"""
+
+    status: Optional[Literal["queued", "processing", "completed", "error"]] = None
+    """Current status of the transcription job"""
+
+    vault_id: Optional[str] = None
+    """Vault ID (only for vault-based transcription)"""

casedev/types/voice/transcription_retrieve_response.py

@@ -5,37 +5,39 @@ from typing_extensions import Literal
 
 from ..._models import BaseModel
 
-__all__ = ["TranscriptionRetrieveResponse", "Word"]
-
-
-class Word(BaseModel):
-    confidence: Optional[float] = None
-
-    end: Optional[float] = None
-
-    start: Optional[float] = None
-
-    text: Optional[str] = None
+__all__ = ["TranscriptionRetrieveResponse"]
 
 
 class TranscriptionRetrieveResponse(BaseModel):
     id: str
     """Unique transcription job ID"""
 
-    status: Literal["queued", "processing", "completed", "error"]
+    status: Literal["queued", "processing", "completed", "failed"]
     """Current status of the transcription job"""
 
     audio_duration: Optional[float] = None
     """Duration of the audio file in seconds"""
 
     confidence: Optional[float] = None
-    """Overall confidence score for the transcription"""
+    """Overall confidence score (0-100)"""
 
     error: Optional[str] = None
-    """Error message (only present when status is error)"""
+    """Error message (only present when status is failed)"""
+
+    result_object_id: Optional[str] = None
+    """Result transcript object ID (vault-based jobs, when completed)"""
+
+    source_object_id: Optional[str] = None
+    """Source audio object ID (vault-based jobs only)"""
 
     text: Optional[str] = None
-    """Full transcription text (only present when status is completed)"""
+    """Full transcription text (legacy direct URL jobs only)"""
+
+    vault_id: Optional[str] = None
+    """Vault ID (vault-based jobs only)"""
+
+    word_count: Optional[int] = None
+    """Number of words in the transcript"""
 
-    words: Optional[List[Word]] = None
-    """Word-level timestamps and confidence scores"""
+    words: Optional[List[object]] = None
+    """Word-level timestamps (legacy direct URL jobs only)"""

casedev/types/voice/v1/__init__.py

@@ -3,4 +3,3 @@
 from __future__ import annotations
 
 from .speak_create_params import SpeakCreateParams as SpeakCreateParams
-from .speak_stream_params import SpeakStreamParams as SpeakStreamParams

casedev/types/voice/v1/speak_create_params.py

@@ -46,6 +46,8 @@ class SpeakCreateParams(TypedDict, total=False):
 
 
 class VoiceSettings(TypedDict, total=False):
+    """Voice customization settings"""
+
     similarity_boost: float
     """Similarity boost (0-1)"""
 

casedev/types/voice/v1_list_voices_response.py

@@ -0,0 +1,40 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["V1ListVoicesResponse", "Voice"]
+
+
+class Voice(BaseModel):
+    available_for_tiers: Optional[List[str]] = None
+    """Available subscription tiers"""
+
+    category: Optional[str] = None
+    """Voice category"""
+
+    description: Optional[str] = None
+    """Voice description"""
+
+    labels: Optional[object] = None
+    """Voice characteristics and metadata"""
+
+    name: Optional[str] = None
+    """Voice name"""
+
+    preview_url: Optional[str] = None
+    """URL to preview audio sample"""
+
+    voice_id: Optional[str] = None
+    """Unique voice identifier"""
+
+
+class V1ListVoicesResponse(BaseModel):
+    next_page_token: Optional[str] = None
+    """Token for next page of results"""
+
+    total_count: Optional[int] = None
+    """Total number of voices (if requested)"""
+
+    voices: Optional[List[Voice]] = None

casedev/types/webhooks/__init__.py

@@ -1,6 +1,3 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from __future__ import annotations
-
-from .v1_create_params import V1CreateParams as V1CreateParams
-from .v1_create_response import V1CreateResponse as V1CreateResponse

{casedev-0.1.0.dist-info → casedev-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: casedev
-Version: 0.1.0
+Version: 0.2.0
 Summary: The official Python library for the casedev API
 Project-URL: Homepage, https://github.com/CaseMark/casedev-python
 Project-URL: Repository, https://github.com/CaseMark/casedev-python
@@ -51,13 +51,10 @@ The REST API documentation can be found on [docs.case.dev](https://docs.case.dev
 ## Installation
 
 ```sh
-# install from the production repo
-pip install git+ssh://git@github.com/CaseMark/casedev-python.git
+# install from PyPI
+pip install casedev
 ```
 
-> [!NOTE]
-> Once this package is [published to PyPI](https://www.stainless.com/docs/guides/publish), this will become: `pip install casedev`
-
 ## Usage
 
 The full API of this library can be found in [api.md](https://github.com/CaseMark/casedev-python/tree/main/api.md).
@@ -128,8 +125,8 @@ By default, the async client uses `httpx` for HTTP requests. However, for improv
 You can enable this by installing `aiohttp`:
 
 ```sh
-# install from the production repo
-pip install 'casedev[aiohttp] @ git+ssh://git@github.com/CaseMark/casedev-python.git'
+# install from PyPI
+pip install casedev[aiohttp]
 ```
 
 Then you can enable it by instantiating the client with `http_client=DefaultAioHttpClient()`:
@@ -178,12 +175,12 @@ from casedev import Casedev
 
 client = Casedev()
 
-response = client.compute.v1.deploy(
-    entrypoint_name="entrypointName",
-    type="task",
-    config={},
+response = client.format.v1.create_document(
+    content="content",
+    output_format="pdf",
+    options={},
 )
-print(response.config)
+print(response.options)
 ```
 
 ## Handling errors