worqhat 3.8.0__py3-none-any.whl → 3.10.0__py3-none-any.whl

worqhat/resources/{client/storage.py → storage.py}

@@ -6,22 +6,22 @@ from typing import Mapping, cast
 
 import httpx
 
-from ..._types import Body, Omit, Query, Headers, NotGiven, FileTypes, omit, not_given
-from ..._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
-from ..._compat import cached_property
-from ..._resource import SyncAPIResource, AsyncAPIResource
-from ..._response import (
+from ..types import storage_upload_file_params, storage_retrieve_file_by_path_params
+from .._types import Body, Omit, Query, Headers, NotGiven, FileTypes, omit, not_given
+from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
     to_raw_response_wrapper,
     to_streamed_response_wrapper,
     async_to_raw_response_wrapper,
     async_to_streamed_response_wrapper,
 )
-from ..._base_client import make_request_options
-from ...types.client import storage_upload_file_params, storage_retrieve_file_by_path_params
-from ...types.client.storage_upload_file_response import StorageUploadFileResponse
-from ...types.client.storage_delete_file_by_id_response import StorageDeleteFileByIDResponse
-from ...types.client.storage_retrieve_file_by_id_response import StorageRetrieveFileByIDResponse
-from ...types.client.storage_retrieve_file_by_path_response import StorageRetrieveFileByPathResponse
+from .._base_client import make_request_options
+from ..types.storage_upload_file_response import StorageUploadFileResponse
+from ..types.storage_delete_file_by_id_response import StorageDeleteFileByIDResponse
+from ..types.storage_retrieve_file_by_id_response import StorageRetrieveFileByIDResponse
+from ..types.storage_retrieve_file_by_path_response import StorageRetrieveFileByPathResponse
 
 __all__ = ["StorageResource", "AsyncStorageResource"]
 

worqhat/types/__init__.py

@@ -2,23 +2,43 @@
 
 from __future__ import annotations
 
+from .db_cluster_params import DBClusterParams as DBClusterParams
+from .db_cluster_response import DBClusterResponse as DBClusterResponse
+from .db_recommend_params import DBRecommendParams as DBRecommendParams
+from .db_recommend_response import DBRecommendResponse as DBRecommendResponse
 from .health_check_response import HealthCheckResponse as HealthCheckResponse
+from .db_find_similar_params import DBFindSimilarParams as DBFindSimilarParams
 from .db_execute_batch_params import DBExecuteBatchParams as DBExecuteBatchParams
 from .db_execute_query_params import DBExecuteQueryParams as DBExecuteQueryParams
+from .db_hybrid_search_params import DBHybridSearchParams as DBHybridSearchParams
 from .db_insert_record_params import DBInsertRecordParams as DBInsertRecordParams
 from .flow_get_metrics_params import FlowGetMetricsParams as FlowGetMetricsParams
 from .db_delete_records_params import DBDeleteRecordsParams as DBDeleteRecordsParams
+from .db_find_similar_response import DBFindSimilarResponse as DBFindSimilarResponse
 from .db_update_records_params import DBUpdateRecordsParams as DBUpdateRecordsParams
 from .get_server_info_response import GetServerInfoResponse as GetServerInfoResponse
 from .db_execute_batch_response import DBExecuteBatchResponse as DBExecuteBatchResponse
 from .db_execute_query_response import DBExecuteQueryResponse as DBExecuteQueryResponse
+from .db_hybrid_search_response import DBHybridSearchResponse as DBHybridSearchResponse
 from .db_insert_record_response import DBInsertRecordResponse as DBInsertRecordResponse
+from .db_semantic_search_params import DBSemanticSearchParams as DBSemanticSearchParams
 from .flow_get_metrics_response import FlowGetMetricsResponse as FlowGetMetricsResponse
 from .db_delete_records_response import DBDeleteRecordsResponse as DBDeleteRecordsResponse
+from .db_detect_anomalies_params import DBDetectAnomaliesParams as DBDetectAnomaliesParams
 from .db_process_nl_query_params import DBProcessNlQueryParams as DBProcessNlQueryParams
 from .db_update_records_response import DBUpdateRecordsResponse as DBUpdateRecordsResponse
+from .storage_upload_file_params import StorageUploadFileParams as StorageUploadFileParams
+from .db_semantic_search_response import DBSemanticSearchResponse as DBSemanticSearchResponse
+from .db_detect_anomalies_response import DBDetectAnomaliesResponse as DBDetectAnomaliesResponse
 from .db_process_nl_query_response import DBProcessNlQueryResponse as DBProcessNlQueryResponse
+from .storage_upload_file_response import StorageUploadFileResponse as StorageUploadFileResponse
 from .flow_trigger_with_file_params import FlowTriggerWithFileParams as FlowTriggerWithFileParams
 from .flow_trigger_with_file_response import FlowTriggerWithFileResponse as FlowTriggerWithFileResponse
 from .flow_trigger_with_payload_params import FlowTriggerWithPayloadParams as FlowTriggerWithPayloadParams
 from .flow_trigger_with_payload_response import FlowTriggerWithPayloadResponse as FlowTriggerWithPayloadResponse
+from .storage_delete_file_by_id_response import StorageDeleteFileByIDResponse as StorageDeleteFileByIDResponse
+from .storage_retrieve_file_by_id_response import StorageRetrieveFileByIDResponse as StorageRetrieveFileByIDResponse
+from .storage_retrieve_file_by_path_params import StorageRetrieveFileByPathParams as StorageRetrieveFileByPathParams
+from .storage_retrieve_file_by_path_response import (
+    StorageRetrieveFileByPathResponse as StorageRetrieveFileByPathResponse,
+)

worqhat/types/db_cluster_params.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 Literal, Required, TypedDict
+
+__all__ = ["DBClusterParams"]
+
+
+class DBClusterParams(TypedDict, total=False):
+    table: Required[str]
+    """Table to cluster"""
+
+    environment: Literal["development", "staging", "production"]
+    """Environment to cluster (development, staging, production)"""
+
+    generate_labels: bool
+    """Whether to generate AI labels for clusters"""
+
+    max_clusters: float
+    """Maximum clusters for auto-detection"""
+
+    min_clusters: float
+    """Minimum clusters for auto-detection"""
+
+    num_clusters: float
+    """Number of clusters (auto-detected if not provided)"""

worqhat/types/db_cluster_response.py

@@ -0,0 +1,44 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["DBClusterResponse", "Cluster"]
+
+
+class Cluster(BaseModel):
+    id: Optional[float] = None
+    """Cluster ID"""
+
+    centroid: Optional[List[float]] = None
+    """Cluster center embedding (first 10 dimensions)"""
+
+    label: Optional[str] = None
+    """AI-generated cluster description"""
+
+    sample_records: Optional[List[Dict[str, object]]] = None
+    """3-5 representative records from cluster"""
+
+    size: Optional[float] = None
+    """Number of records in cluster"""
+
+
+class DBClusterResponse(BaseModel):
+    clusters: Optional[List[Cluster]] = None
+
+    execution_time: Optional[float] = FieldInfo(alias="executionTime", default=None)
+    """Clustering execution time in milliseconds"""
+
+    iterations: Optional[float] = None
+    """Number of K-means iterations performed"""
+
+    optimal_k: Optional[float] = None
+    """Determined optimal cluster count"""
+
+    silhouette_score: Optional[float] = None
+    """Clustering quality metric (0-1)"""
+
+    success: Optional[bool] = None

worqhat/types/db_detect_anomalies_params.py

@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["DBDetectAnomaliesParams"]
+
+
+class DBDetectAnomaliesParams(TypedDict, total=False):
+    table: Required[str]
+    """Table to analyze for anomalies"""
+
+    environment: Literal["development", "staging", "production"]
+    """Environment to analyze (development, staging, production)"""
+
+    k: float
+    """Number of nearest neighbors to consider"""
+
+    limit: float
+    """Maximum number of anomalies to return"""
+
+    threshold: float
+    """Minimum anomaly score threshold"""

worqhat/types/db_detect_anomalies_response.py

@@ -0,0 +1,50 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["DBDetectAnomaliesResponse", "Anomaly", "AnomalyNearestNeighbor", "Parameters"]
+
+
+class AnomalyNearestNeighbor(BaseModel):
+    distance: Optional[float] = None
+
+    record: Optional[Dict[str, object]] = None
+
+
+class Anomaly(BaseModel):
+    anomaly_score: Optional[float] = None
+    """Anomaly score (0-1, higher = more unusual)"""
+
+    avg_distance: Optional[float] = None
+    """Average distance to K nearest neighbors"""
+
+    nearest_neighbors: Optional[List[AnomalyNearestNeighbor]] = None
+
+    record: Optional[Dict[str, object]] = None
+
+
+class Parameters(BaseModel):
+    k: Optional[float] = None
+
+    threshold: Optional[float] = None
+
+
+class DBDetectAnomaliesResponse(BaseModel):
+    anomalies: Optional[List[Anomaly]] = None
+
+    anomaly_count: Optional[float] = None
+    """Number of anomalies detected"""
+
+    execution_time: Optional[float] = FieldInfo(alias="executionTime", default=None)
+    """Analysis execution time in milliseconds"""
+
+    parameters: Optional[Parameters] = None
+
+    success: Optional[bool] = None
+
+    total_records: Optional[float] = None
+    """Total number of records analyzed"""

worqhat/types/db_execute_query_params.py

@@ -2,18 +2,23 @@
 
 from __future__ import annotations
 
-from typing import Dict
+from typing import Dict, Union
 from typing_extensions import Literal, Required, TypedDict
 
+from .._types import SequenceNotStr
+
 __all__ = ["DBExecuteQueryParams"]
 
 
 class DBExecuteQueryParams(TypedDict, total=False):
     query: Required[str]
-    """SQL query to execute"""
+    """SQL query to execute.
+
+    Supports both named parameters ({param}) and positional parameters ($1, $2)
+    """
 
     environment: Literal["development", "staging", "production"]
     """Environment to query (development, staging, production)"""
 
-    params: Dict[str, object]
-    """Optional query parameters"""
+    params: Union[Dict[str, object], SequenceNotStr[Union[str, float, bool]]]
+    """Named parameters for queries with {param} syntax"""

worqhat/types/db_find_similar_params.py

@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["DBFindSimilarParams"]
+
+
+class DBFindSimilarParams(TypedDict, total=False):
+    record_id: Required[Union[str, float]]
+    """ID of the source record"""
+
+    table: Required[str]
+    """Table containing the source record"""
+
+    environment: Literal["development", "staging", "production"]
+    """Environment to search in (development, staging, production)"""
+
+    exclude_self: bool
+    """Whether to exclude the source record from results"""
+
+    limit: float
+    """Maximum number of similar records to return"""
+
+    target_table: str
+    """Different table to search in (optional)"""
+
+    threshold: float
+    """Minimum similarity score threshold"""

worqhat/types/db_find_similar_response.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["DBFindSimilarResponse", "SimilarRecord"]
+
+
+class SimilarRecord(BaseModel):
+    record: Optional[Dict[str, object]] = None
+
+    similarity: Optional[float] = None
+    """Similarity score (0-1)"""
+
+    table: Optional[str] = None
+
+
+class DBFindSimilarResponse(BaseModel):
+    execution_time: Optional[float] = FieldInfo(alias="executionTime", default=None)
+    """Search execution time in milliseconds"""
+
+    similar_records: Optional[List[SimilarRecord]] = None
+
+    source_record: Optional[Dict[str, object]] = None
+    """The original record used for similarity search"""
+
+    success: Optional[bool] = None

worqhat/types/db_hybrid_search_params.py

@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["DBHybridSearchParams"]
+
+
+class DBHybridSearchParams(TypedDict, total=False):
+    query: Required[str]
+    """Search query combining natural language and keywords"""
+
+    table: Required[str]
+    """Table to search in"""
+
+    environment: Literal["development", "staging", "production"]
+    """Environment to search in (development, staging, production)"""
+
+    keyword_weight: float
+    """Weight for keyword matching score"""
+
+    limit: float
+    """Maximum number of results to return"""
+
+    semantic_weight: float
+    """Weight for semantic similarity score"""
+
+    text_columns: SequenceNotStr[str]
+    """Columns to include in keyword search"""

worqhat/types/db_hybrid_search_response.py

@@ -0,0 +1,48 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["DBHybridSearchResponse", "Result", "Result_Meta", "Result_MetaWeights"]
+
+
+class Result_MetaWeights(BaseModel):
+    keyword: Optional[float] = None
+
+    semantic: Optional[float] = None
+
+
+class Result_Meta(BaseModel):
+    search_type: Optional[str] = None
+
+    weights: Optional[Result_MetaWeights] = None
+
+
+class Result(BaseModel):
+    api_meta: Optional[Result_Meta] = FieldInfo(alias="_meta", default=None)
+
+    combined_score: Optional[float] = None
+    """Combined semantic + keyword score"""
+
+    keyword_score: Optional[float] = None
+    """Keyword matching score"""
+
+    record: Optional[Dict[str, object]] = None
+
+    semantic_score: Optional[float] = None
+    """Semantic similarity score"""
+
+
+class DBHybridSearchResponse(BaseModel):
+    execution_time: Optional[float] = FieldInfo(alias="executionTime", default=None)
+    """Search execution time in milliseconds"""
+
+    query_embedding_preview: Optional[List[float]] = None
+    """First 5 dimensions of the query embedding"""
+
+    results: Optional[List[Result]] = None
+
+    success: Optional[bool] = None

worqhat/types/db_process_nl_query_params.py

@@ -12,9 +12,6 @@ class DBProcessNlQueryParams(TypedDict, total=False):
     question: Required[str]
     """Natural language question"""
 
-    table: Required[str]
-    """Table name to query"""
-
     context: Dict[str, object]
     """Optional context for the query"""
 

worqhat/types/db_recommend_params.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union
+from typing_extensions import Literal, Required, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["DBRecommendParams"]
+
+
+class DBRecommendParams(TypedDict, total=False):
+    table: Required[str]
+    """Table to generate recommendations from"""
+
+    environment: Literal["development", "staging", "production"]
+    """Environment to search in (development, staging, production)"""
+
+    exclude_ids: SequenceNotStr[str]
+    """Record IDs to exclude from recommendations"""
+
+    limit: float
+    """Maximum number of recommendations to return"""
+
+    record_id: Union[str, float]
+    """Source item ID for item-to-item recommendations"""
+
+    strategy: Literal["similar", "diverse", "popular"]
+    """Recommendation strategy to use"""
+
+    user_history: SequenceNotStr[str]
+    """Array of record IDs the user has interacted with"""

worqhat/types/db_recommend_response.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["DBRecommendResponse", "Recommendation", "Recommendation_Meta"]
+
+
+class Recommendation_Meta(BaseModel):
+    source: Optional[str] = None
+
+    strategy: Optional[str] = None
+
+
+class Recommendation(BaseModel):
+    api_meta: Optional[Recommendation_Meta] = FieldInfo(alias="_meta", default=None)
+
+    record: Optional[Dict[str, object]] = None
+
+    similarity: Optional[float] = None
+    """Similarity score (0-1)"""
+
+
+class DBRecommendResponse(BaseModel):
+    execution_time: Optional[float] = FieldInfo(alias="executionTime", default=None)
+    """Recommendation generation time in milliseconds"""
+
+    recommendations: Optional[List[Recommendation]] = None
+
+    strategy: Optional[str] = None
+    """Strategy used for recommendations"""
+
+    success: Optional[bool] = None

worqhat/types/db_semantic_search_params.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict
+from typing_extensions import Literal, Required, TypedDict
+
+from .._types import SequenceNotStr
+
+__all__ = ["DBSemanticSearchParams"]
+
+
+class DBSemanticSearchParams(TypedDict, total=False):
+    query: Required[str]
+    """Natural language search query"""
+
+    environment: Literal["development", "staging", "production"]
+    """Environment to search in (development, staging, production)"""
+
+    filters: Dict[str, object]
+    """Additional WHERE conditions to apply"""
+
+    limit: float
+    """Maximum number of results to return"""
+
+    table: str
+    """Single table to search in (optional if tables is provided)"""
+
+    tables: SequenceNotStr[str]
+    """Multiple tables to search across (optional if table is provided)"""
+
+    threshold: float
+    """Minimum similarity score threshold"""

worqhat/types/db_semantic_search_response.py

@@ -0,0 +1,36 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+
+__all__ = ["DBSemanticSearchResponse", "Result", "Result_Meta"]
+
+
+class Result_Meta(BaseModel):
+    matched_fields: Optional[List[str]] = None
+
+
+class Result(BaseModel):
+    api_meta: Optional[Result_Meta] = FieldInfo(alias="_meta", default=None)
+
+    record: Optional[Dict[str, object]] = None
+
+    similarity: Optional[float] = None
+    """Similarity score (0-1)"""
+
+    table: Optional[str] = None
+
+
+class DBSemanticSearchResponse(BaseModel):
+    execution_time: Optional[float] = FieldInfo(alias="executionTime", default=None)
+    """Search execution time in milliseconds"""
+
+    query_embedding_preview: Optional[List[float]] = None
+    """First 5 dimensions of the query embedding"""
+
+    results: Optional[List[Result]] = None
+
+    success: Optional[bool] = None

worqhat/types/{client/storage_delete_file_by_id_response.py → storage_delete_file_by_id_response.py}

@@ -5,7 +5,7 @@ from datetime import datetime
 
 from pydantic import Field as FieldInfo
 
-from ..._models import BaseModel
+from .._models import BaseModel
 
 __all__ = ["StorageDeleteFileByIDResponse"]
 

worqhat/types/{client/storage_retrieve_file_by_id_response.py → storage_retrieve_file_by_id_response.py}

@@ -5,7 +5,7 @@ from datetime import datetime
 
 from pydantic import Field as FieldInfo
 
-from ..._models import BaseModel
+from .._models import BaseModel
 
 __all__ = ["StorageRetrieveFileByIDResponse", "File"]
 

worqhat/types/{client/storage_retrieve_file_by_path_response.py → storage_retrieve_file_by_path_response.py}

@@ -5,7 +5,7 @@ from datetime import datetime
 
 from pydantic import Field as FieldInfo
 
-from ..._models import BaseModel
+from .._models import BaseModel
 
 __all__ = ["StorageRetrieveFileByPathResponse", "File"]
 

worqhat/types/{client/storage_upload_file_params.py → storage_upload_file_params.py}

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing_extensions import Required, TypedDict
 
-from ..._types import FileTypes
+from .._types import FileTypes
 
 __all__ = ["StorageUploadFileParams"]
 

worqhat/types/{client/storage_upload_file_response.py → storage_upload_file_response.py}

@@ -5,7 +5,7 @@ from datetime import datetime
 
 from pydantic import Field as FieldInfo
 
-from ..._models import BaseModel
+from .._models import BaseModel
 
 __all__ = ["StorageUploadFileResponse", "File"]
 

{worqhat-3.8.0.dist-info → worqhat-3.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: worqhat
-Version: 3.8.0
+Version: 3.10.0
 Summary: The official Python library for the worqhat API
 Project-URL: Homepage, https://github.com/WorqHat/worqhat-python-sdk
 Project-URL: Repository, https://github.com/WorqHat/worqhat-python-sdk