erdo 0.1.4__py3-none-any.whl

erdo/_generated/actions/memory.py

@@ -0,0 +1,252 @@
+"""
+Memory management actions for storing, searching, and managing memories service functions.
+Auto-generated - DO NOT EDIT.
+
+Provides type-safe action definitions for memory service.
+Actual execution happens in the Go backend after syncing.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+from erdo._generated.types import Memory
+from erdo.template import TemplateString
+from erdo.types import StepMetadata
+
+
+class SearchParams(BaseModel):
+    """Search memories using semantic search with optional filters parameters"""
+
+    name: str = "memory.search"  # Action type for roundtrip compatibility
+    query: Optional[Union[str, TemplateString]] = None  # query parameter
+    organization_scope: Optional[Union[str, TemplateString]] = (
+        None  # organization_scope parameter
+    )
+    user_scope: Optional[Union[str, TemplateString]] = None  # user_scope parameter
+    thread_id: Optional[Union[str, TemplateString]] = None  # thread_id parameter
+    dataset_id: Optional[Union[str, TemplateString]] = None  # dataset_id parameter
+    integration_config_id: Optional[Union[str, TemplateString]] = (
+        None  # integration_config_id parameter
+    )
+    approval_status: Optional[Union[str, TemplateString]] = (
+        None  # approval_status parameter
+    )
+    limit: Optional[Union[int, TemplateString]] = None  # limit parameter
+    max_distance: Optional[Any] = None  # max_distance parameter
+
+
+class SearchFromQueriesParams(BaseModel):
+    """Search memories using multiple queries including integration-specific queries parameters"""
+
+    name: str = "memory.search_from_queries"  # Action type for roundtrip compatibility
+    queries: Optional[Any] = None  # queries parameter
+    integration_queries: Optional[Any] = None  # integration_queries parameter
+    organization_scope: Optional[Union[str, TemplateString]] = (
+        None  # organization_scope parameter
+    )
+    user_scope: Optional[Union[str, TemplateString]] = None  # user_scope parameter
+    thread_id: Optional[Union[str, TemplateString]] = None  # thread_id parameter
+    limit: Optional[Union[int, TemplateString]] = None  # limit parameter
+    max_distance: Optional[Any] = None  # max_distance parameter
+
+
+class ProcessIntegrationQueriesParams(BaseModel):
+    """Process integration queries to create resource-specific search queries parameters"""
+
+    name: str = (
+        "memory.process_integration_queries"  # Action type for roundtrip compatibility
+    )
+    query: Optional[Union[str, TemplateString]] = None  # query parameter
+    resource: Optional[Any] = None  # resource parameter
+    queries: Optional[Any] = None  # queries parameter
+
+
+class StoreParams(BaseModel):
+    """Store or update a memory with content, metadata, and scope settings parameters"""
+
+    name: str = "memory.store"  # Action type for roundtrip compatibility
+    memory: Optional[Any] = None  # memory parameter
+
+
+class SearchResult(BaseModel):
+    """Search memories using semantic search with optional filters result type
+
+    Result schema for memory.search action.
+    """
+
+    memories: List[Memory]
+
+
+class SearchFromQueriesResult(BaseModel):
+    """Search memories using multiple queries including integration-specific queries result type
+
+    Result schema for memory.search_from_queries action.
+    """
+
+    data: Optional[Dict[str, Any]]  # Action result data
+
+
+class ProcessIntegrationQueriesResult(BaseModel):
+    """Process integration queries to create resource-specific search queries result type
+
+    Result schema for memory.process_integration_queries action.
+    """
+
+    data: Optional[Dict[str, Any]]  # Action result data
+
+
+class StoreResult(BaseModel):
+    """Store or update a memory with content, metadata, and scope settings result type
+
+    Result schema for memory.store action.
+    """
+
+    memory: Any
+
+
+def search(
+    query: Optional[Union[str, TemplateString]] = None,
+    organization_scope: Optional[Union[str, TemplateString]] = None,
+    user_scope: Optional[Union[str, TemplateString]] = None,
+    thread_id: Optional[Union[str, TemplateString]] = None,
+    dataset_id: Optional[Union[str, TemplateString]] = None,
+    integration_config_id: Optional[Union[str, TemplateString]] = None,
+    approval_status: Optional[Union[str, TemplateString]] = None,
+    limit: Optional[Union[int, TemplateString]] = None,
+    max_distance: Optional[Any] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> SearchParams:
+    """Search memories using semantic search with optional filters
+
+    Args:
+        query: query parameter
+        organization_scope: organization_scope parameter
+        user_scope: user_scope parameter
+        thread_id: thread_id parameter
+        dataset_id: dataset_id parameter
+        integration_config_id: integration_config_id parameter
+        approval_status: approval_status parameter
+        limit: limit parameter
+        max_distance: max_distance parameter
+
+    Returns:
+        SearchParams: Type-safe parameter object
+    """
+    param_dict = {
+        "query": query,
+        "organization_scope": organization_scope,
+        "user_scope": user_scope,
+        "thread_id": thread_id,
+        "dataset_id": dataset_id,
+        "integration_config_id": integration_config_id,
+        "approval_status": approval_status,
+        "limit": limit,
+        "max_distance": max_distance,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+
+    return SearchParams(**param_dict)
+
+
+def search_from_queries(
+    queries: Optional[Any] = None,
+    integration_queries: Optional[Any] = None,
+    organization_scope: Optional[Union[str, TemplateString]] = None,
+    user_scope: Optional[Union[str, TemplateString]] = None,
+    thread_id: Optional[Union[str, TemplateString]] = None,
+    limit: Optional[Union[int, TemplateString]] = None,
+    max_distance: Optional[Any] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> SearchFromQueriesParams:
+    """Search memories using multiple queries including integration-specific queries
+
+    Args:
+        queries: queries parameter
+        integration_queries: integration_queries parameter
+        organization_scope: organization_scope parameter
+        user_scope: user_scope parameter
+        thread_id: thread_id parameter
+        limit: limit parameter
+        max_distance: max_distance parameter
+
+    Returns:
+        SearchFromQueriesParams: Type-safe parameter object
+    """
+    param_dict = {
+        "queries": queries,
+        "integration_queries": integration_queries,
+        "organization_scope": organization_scope,
+        "user_scope": user_scope,
+        "thread_id": thread_id,
+        "limit": limit,
+        "max_distance": max_distance,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+
+    return SearchFromQueriesParams(**param_dict)
+
+
+def process_integration_queries(
+    query: Optional[Union[str, TemplateString]] = None,
+    resource: Optional[Any] = None,
+    queries: Optional[Any] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> ProcessIntegrationQueriesParams:
+    """Process integration queries to create resource-specific search queries
+
+    Args:
+        query: query parameter
+        resource: resource parameter
+        queries: queries parameter
+
+    Returns:
+        ProcessIntegrationQueriesParams: Type-safe parameter object
+    """
+    param_dict = {
+        "query": query,
+        "resource": resource,
+        "queries": queries,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+
+    return ProcessIntegrationQueriesParams(**param_dict)
+
+
+def store(
+    memory: Optional[Any] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> StoreParams:
+    """Store or update a memory with content, metadata, and scope settings
+
+    Args:
+        memory: memory parameter
+
+    Returns:
+        StoreParams: Type-safe parameter object
+    """
+    param_dict = {
+        "memory": memory,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+
+    return StoreParams(**param_dict)
+
+
+# Associate parameter classes with their result types
+SearchParams._result = SearchResult
+SearchFromQueriesParams._result = SearchFromQueriesResult
+ProcessIntegrationQueriesParams._result = ProcessIntegrationQueriesResult
+StoreParams._result = StoreResult

erdo/_generated/actions/resource_definitions.py

@@ -0,0 +1,194 @@
+"""
+Resource definition actions for managing and searching data resources service functions.
+Auto-generated - DO NOT EDIT.
+
+Provides type-safe action definitions for resource_definitions service.
+Actual execution happens in the Go backend after syncing.
+"""
+
+from typing import Any, List, Optional, Union
+
+from pydantic import BaseModel
+
+from erdo._generated.types import Resource
+from erdo.template import TemplateString
+from erdo.types import StepMetadata
+
+
+class SearchParams(BaseModel):
+    """Search for resource definitions using query and key filters parameters"""
+
+    name: str = "resource_definitions.search"  # Action type for roundtrip compatibility
+    query: Optional[Union[str, TemplateString]] = None  # query parameter
+    or_keys: Optional[Any] = None  # or_keys parameter
+    and_keys: Optional[Any] = None  # and_keys parameter
+    dataset_id: Optional[Union[str, TemplateString]] = None  # dataset_id parameter
+    integration_config_id: Optional[Union[str, TemplateString]] = (
+        None  # integration_config_id parameter
+    )
+    limit: Optional[Union[int, TemplateString]] = None  # limit parameter
+
+
+class ListParams(BaseModel):
+    """List resource definitions with optional filtering by dataset, integration, or attach type parameters"""
+
+    name: str = "resource_definitions.list"  # Action type for roundtrip compatibility
+    dataset_id: Optional[Union[str, TemplateString]] = None  # dataset_id parameter
+    integration_config_id: Optional[Union[str, TemplateString]] = (
+        None  # integration_config_id parameter
+    )
+    attach_type: Optional[Union[str, TemplateString]] = None  # attach_type parameter
+    limit: Optional[Union[int, TemplateString]] = None  # limit parameter
+
+
+class ListByKeysParams(BaseModel):
+    """List resource definitions filtered by specific keys with optional additional filters parameters"""
+
+    name: str = (
+        "resource_definitions.list_by_keys"  # Action type for roundtrip compatibility
+    )
+    keys: Optional[Any] = None  # keys parameter
+    dataset_id: Optional[Union[str, TemplateString]] = None  # dataset_id parameter
+    integration_config_id: Optional[Union[str, TemplateString]] = (
+        None  # integration_config_id parameter
+    )
+    attach_type: Optional[Union[str, TemplateString]] = None  # attach_type parameter
+    limit: Optional[Union[int, TemplateString]] = None  # limit parameter
+
+
+class SearchResult(BaseModel):
+    """Search for resource definitions using query and key filters result type
+
+    Result schema for resource_definitions.search action.
+    """
+
+    resource_definitions: List[Resource]
+
+
+class ListResult(BaseModel):
+    """List resource definitions with optional filtering by dataset, integration, or attach type result type
+
+    Result schema for resource_definitions.list action.
+    """
+
+    resource_definitions: List[Resource]
+
+
+class ListByKeysResult(BaseModel):
+    """List resource definitions filtered by specific keys with optional additional filters result type
+
+    Result schema for resource_definitions.list_by_keys action.
+    """
+
+    resource_definitions: List[Resource]
+
+
+def search(
+    query: Optional[Union[str, TemplateString]] = None,
+    or_keys: Optional[Any] = None,
+    and_keys: Optional[Any] = None,
+    dataset_id: Optional[Union[str, TemplateString]] = None,
+    integration_config_id: Optional[Union[str, TemplateString]] = None,
+    limit: Optional[Union[int, TemplateString]] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> SearchParams:
+    """Search for resource definitions using query and key filters
+
+    Args:
+        query: query parameter
+        or_keys: or_keys parameter
+        and_keys: and_keys parameter
+        dataset_id: dataset_id parameter
+        integration_config_id: integration_config_id parameter
+        limit: limit parameter
+
+    Returns:
+        SearchParams: Type-safe parameter object
+    """
+    param_dict = {
+        "query": query,
+        "or_keys": or_keys,
+        "and_keys": and_keys,
+        "dataset_id": dataset_id,
+        "integration_config_id": integration_config_id,
+        "limit": limit,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+
+    return SearchParams(**param_dict)
+
+
+def list(
+    dataset_id: Optional[Union[str, TemplateString]] = None,
+    integration_config_id: Optional[Union[str, TemplateString]] = None,
+    attach_type: Optional[Union[str, TemplateString]] = None,
+    limit: Optional[Union[int, TemplateString]] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> ListParams:
+    """List resource definitions with optional filtering by dataset, integration, or attach type
+
+    Args:
+        dataset_id: dataset_id parameter
+        integration_config_id: integration_config_id parameter
+        attach_type: attach_type parameter
+        limit: limit parameter
+
+    Returns:
+        ListParams: Type-safe parameter object
+    """
+    param_dict = {
+        "dataset_id": dataset_id,
+        "integration_config_id": integration_config_id,
+        "attach_type": attach_type,
+        "limit": limit,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+
+    return ListParams(**param_dict)
+
+
+def list_by_keys(
+    keys: Optional[Any] = None,
+    dataset_id: Optional[Union[str, TemplateString]] = None,
+    integration_config_id: Optional[Union[str, TemplateString]] = None,
+    attach_type: Optional[Union[str, TemplateString]] = None,
+    limit: Optional[Union[int, TemplateString]] = None,
+    step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
+) -> ListByKeysParams:
+    """List resource definitions filtered by specific keys with optional additional filters
+
+    Args:
+        keys: keys parameter
+        dataset_id: dataset_id parameter
+        integration_config_id: integration_config_id parameter
+        attach_type: attach_type parameter
+        limit: limit parameter
+
+    Returns:
+        ListByKeysParams: Type-safe parameter object
+    """
+    param_dict = {
+        "keys": keys,
+        "dataset_id": dataset_id,
+        "integration_config_id": integration_config_id,
+        "attach_type": attach_type,
+        "limit": limit,
+    }
+    # Remove None values for optional parameters
+    param_dict = {k: v for k, v in param_dict.items() if v is not None}
+    param_dict.update(params)
+
+    return ListByKeysParams(**param_dict)
+
+
+# Associate parameter classes with their result types
+SearchParams._result = SearchResult
+ListParams._result = ListResult
+ListByKeysParams._result = ListByKeysResult