reasoning_layer_python_sdk 1.0.0__py3-none-any.whl

reasoning_layer_python_sdk/resources/statistical.py

@@ -0,0 +1,93 @@
+from ..generated.api.statistical_api import StatisticalApi
+from ..generated.api_client import ApiClient
+
+
+class StatisticalClient:
+    """Client for statistical operations."""
+
+    def __init__(self, api_client: ApiClient) -> None:
+        self._api = StatisticalApi(api_client)
+
+    def clear(self):
+        return self._api.clear_statistical_data()
+
+    def discover_causal(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.discover_causal_request import DiscoverCausalRequest
+
+            request = DiscoverCausalRequest(**kwargs)
+        return self._api.discover_causal(discover_causal_request=request)
+
+    def dynamic_discovery(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.dynamic_discovery_request import (
+                DynamicDiscoveryRequest,
+            )
+
+            request = DynamicDiscoveryRequest(**kwargs)
+        return self._api.dynamic_discovery(dynamic_discovery_request=request)
+
+    def get_correlation(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.correlation_request import CorrelationRequest
+
+            request = CorrelationRequest(**kwargs)
+        return self._api.get_correlation(correlation_request=request)
+
+    def get_discovery_status(self):
+        return self._api.get_discovery_status()
+
+    def get_partial_correlation(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.partial_correlation_request import (
+                PartialCorrelationRequest,
+            )
+
+            request = PartialCorrelationRequest(**kwargs)
+        return self._api.get_partial_correlation(partial_correlation_request=request)
+
+    def observe_multi(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.observe_multi_request import ObserveMultiRequest
+
+            request = ObserveMultiRequest(**kwargs)
+        return self._api.observe_multi(observe_multi_request=request)
+
+    def observe_pair(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.observe_pair_request import ObservePairRequest
+
+            request = ObservePairRequest(**kwargs)
+        return self._api.observe_pair(observe_pair_request=request)
+
+    def observe_single(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.observe_single_request import ObserveSingleRequest
+
+            request = ObserveSingleRequest(**kwargs)
+        return self._api.observe_single(observe_single_request=request)
+
+    def record_intervention_observation(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.intervention_observation_request import (
+                InterventionObservationRequest,
+            )
+
+            request = InterventionObservationRequest(**kwargs)
+        return self._api.record_intervention_observation(
+            intervention_observation_request=request
+        )
+
+    def reset_discovery(self):
+        return self._api.reset_discovery()
+
+    def test_conditional_independence(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.conditional_independence_request import (
+                ConditionalIndependenceRequest,
+            )
+
+            request = ConditionalIndependenceRequest(**kwargs)
+        return self._api.test_conditional_independence(
+            conditional_independence_request=request
+        )

reasoning_layer_python_sdk/resources/strings.py

@@ -0,0 +1,87 @@
+from ..generated.api.strings_api import StringsApi
+from ..generated.api_client import ApiClient
+
+
+class StringsClient:
+    """Client for string operations."""
+
+    def __init__(self, api_client: ApiClient) -> None:
+        self._api = StringsApi(api_client)
+
+    def number_to_string(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.number_to_string_request import (
+                NumberToStringRequest,
+            )
+
+            request = NumberToStringRequest(**kwargs)
+        return self._api.number_to_string(number_to_string_request=request)
+
+    def asc(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.asc_request import AscRequest
+
+            request = AscRequest(**kwargs)
+        return self._api.string_asc(asc_request=request)
+
+    def chr(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.chr_request import ChrRequest
+
+            request = ChrRequest(**kwargs)
+        return self._api.string_chr(chr_request=request)
+
+    def compare(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.string_compare_request import StringCompareRequest
+
+            request = StringCompareRequest(**kwargs)
+        return self._api.string_compare(string_compare_request=request)
+
+    def compare_batch(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.batch_string_compare_request import (
+                BatchStringCompareRequest,
+            )
+
+            request = BatchStringCompareRequest(**kwargs)
+        return self._api.string_compare_batch(batch_string_compare_request=request)
+
+    def compare_predicate(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.string_compare_predicate_request import (
+                StringComparePredicateRequest,
+            )
+
+            request = StringComparePredicateRequest(**kwargs)
+        return self._api.string_compare_predicate(
+            string_compare_predicate_request=request
+        )
+
+    def concat(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.string_concat_request import StringConcatRequest
+
+            request = StringConcatRequest(**kwargs)
+        return self._api.string_concat(string_concat_request=request)
+
+    def length(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.string_length_request import StringLengthRequest
+
+            request = StringLengthRequest(**kwargs)
+        return self._api.string_length(string_length_request=request)
+
+    def op(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.string_op_request import StringOpRequest
+
+            request = StringOpRequest(**kwargs)
+        return self._api.string_op(string_op_request=request)
+
+    def substr(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.substring_request import SubstringRequest
+
+            request = SubstringRequest(**kwargs)
+        return self._api.string_substr(substring_request=request)

reasoning_layer_python_sdk/resources/structured_ingestion.py

@@ -0,0 +1,45 @@
+from ..generated.api.structured_ingestion_api import StructuredIngestionApi
+from ..generated.api_client import ApiClient
+
+
+class StructuredIngestionClient:
+    """Client for structured ingestion operations."""
+
+    def __init__(self, api_client: ApiClient) -> None:
+        self._api = StructuredIngestionApi(api_client)
+
+    def delete_source(self, source_id: str):
+        return self._api.delete_source(source_id=source_id)
+
+    def discover_schema(self, source_id: str, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.discover_schema_request import DiscoverSchemaRequest
+
+            request = DiscoverSchemaRequest(**kwargs)
+        return self._api.discover_schema(
+            source_id=source_id, discover_schema_request=request
+        )
+
+    def get_source(self, source_id: str):
+        return self._api.get_source(source_id=source_id)
+
+    def ingest_from_source(self, source_id: str, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.ingest_from_source_request import (
+                IngestFromSourceRequest,
+            )
+
+            request = IngestFromSourceRequest(**kwargs)
+        return self._api.ingest_from_source(
+            source_id=source_id, ingest_from_source_request=request
+        )
+
+    def list_sources(self):
+        return self._api.list_sources()
+
+    def register_source(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.register_source_request import RegisterSourceRequest
+
+            request = RegisterSourceRequest(**kwargs)
+        return self._api.register_source(register_source_request=request)

reasoning_layer_python_sdk/resources/synthetic.py

@@ -0,0 +1,84 @@
+from ..generated.api.synthetic_api import SyntheticApi
+from ..generated.api_client import ApiClient
+
+
+class SyntheticClient:
+    """Client for synthetic data operations."""
+
+    def __init__(self, api_client: ApiClient) -> None:
+        self._api = SyntheticApi(api_client)
+
+    def build_generation_prompt(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.generation_prompt_request import (
+                GenerationPromptRequest,
+            )
+
+            request = GenerationPromptRequest(**kwargs)
+        return self._api.build_generation_prompt(generation_prompt_request=request)
+
+    def calibrate(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.calibrate_request import CalibrateRequest
+
+            request = CalibrateRequest(**kwargs)
+        return self._api.calibrate(calibrate_request=request)
+
+    def check_diversity(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.check_diversity_request import CheckDiversityRequest
+
+            request = CheckDiversityRequest(**kwargs)
+        return self._api.check_diversity(check_diversity_request=request)
+
+    def export_jsonl(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.generate_synthetic_data_request import (
+                GenerateSyntheticDataRequest,
+            )
+
+            request = GenerateSyntheticDataRequest(**kwargs)
+        return self._api.export_jsonl(generate_synthetic_data_request=request)
+
+    def generate_negatives(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.generate_negatives_request import (
+                GenerateNegativesRequest,
+            )
+
+            request = GenerateNegativesRequest(**kwargs)
+        return self._api.generate_negatives(generate_negatives_request=request)
+
+    def generate(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.generate_synthetic_data_request import (
+                GenerateSyntheticDataRequest,
+            )
+
+            request = GenerateSyntheticDataRequest(**kwargs)
+        return self._api.generate_synthetic(generate_synthetic_data_request=request)
+
+    def verbalize_term(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.verbalize_term_request import VerbalizeTermRequest
+
+            request = VerbalizeTermRequest(**kwargs)
+        return self._api.verbalize_term(verbalize_term_request=request)
+
+    def verify_faithfulness(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.verify_faithfulness_request import (
+                VerifyFaithfulnessRequest,
+            )
+
+            request = VerifyFaithfulnessRequest(**kwargs)
+        return self._api.verify_faithfulness(verify_faithfulness_request=request)
+
+    def verify_round_trip(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.verify_round_trip_request import (
+                VerifyRoundTripRequest,
+            )
+
+            request = VerifyRoundTripRequest(**kwargs)
+        return self._api.verify_round_trip(verify_round_trip_request=request)

reasoning_layer_python_sdk/resources/templates.py

@@ -0,0 +1,39 @@
+from ..generated.api.templates_api import TemplatesApi
+from ..generated.api_client import ApiClient
+
+
+class TemplatesClient:
+    """Client for template management."""
+
+    def __init__(self, api_client: ApiClient) -> None:
+        self._api = TemplatesApi(api_client)
+
+    def create(self, *, request=None, **kwargs):
+        """Create a template."""
+        if request is None:
+            from ..generated.models.create_template_request_dto import (
+                CreateTemplateRequestDto,
+            )
+
+            request = CreateTemplateRequestDto(**kwargs)
+        return self._api.create_template(create_template_request_dto=request)
+
+    def delete(self, template_id: str):
+        """Delete a template."""
+        return self._api.delete_template_handler(id=template_id)
+
+    def list(self):
+        """List all templates."""
+        return self._api.list_templates_handler()
+
+    def update(self, template_id: str, *, request=None, **kwargs):
+        """Update a template."""
+        if request is None:
+            from ..generated.models.update_template_request_dto import (
+                UpdateTemplateRequestDto,
+            )
+
+            request = UpdateTemplateRequestDto(**kwargs)
+        return self._api.update_template_handler(
+            id=template_id, update_template_request_dto=request
+        )

reasoning_layer_python_sdk/resources/terms.py

@@ -0,0 +1,139 @@
+from typing import Any, Dict, Optional
+from uuid import UUID
+
+from ..builders import Value
+from ..generated.api.terms_api import TermsApi
+from ..generated.api_client import ApiClient
+from ..generated.models.bulk_add_terms_request import BulkAddTermsRequest
+from ..generated.models.bulk_add_terms_response import BulkAddTermsResponse
+from ..generated.models.clear_terms_response import ClearTermsResponse
+from ..generated.models.create_term_request import CreateTermRequest
+from ..generated.models.term_exists_response import TermExistsResponse
+from ..generated.models.term_list_response import TermListResponse
+from ..generated.models.term_response import TermResponse
+from ..generated.models.update_term_request import UpdateTermRequest
+from ..generated.models.value_dto import ValueDto
+
+
+def _coerce_features(features: Dict[str, Any]) -> Dict[str, ValueDto]:
+    """Convert plain Python primitives in a features dict to ``ValueDto``."""
+    coerced: Dict[str, ValueDto] = {}
+    for key, val in features.items():
+        if isinstance(val, ValueDto):
+            coerced[key] = val
+        elif isinstance(val, str):
+            coerced[key] = Value.string(val)
+        elif isinstance(val, bool):
+            # bool must be checked before int because bool is a subclass of int
+            coerced[key] = Value.boolean(val)
+        elif isinstance(val, int):
+            coerced[key] = Value.integer(val)
+        elif isinstance(val, float):
+            coerced[key] = Value.real(val)
+        elif isinstance(val, UUID):
+            coerced[key] = Value.reference(val)
+        elif isinstance(val, list):
+            coerced[key] = Value.list_of(*val)
+        else:
+            raise TypeError(
+                f"Unsupported feature value type for key {key!r}: {type(val).__name__}"
+            )
+    return coerced
+
+
+class TermsClient:
+    """Client for term-related operations."""
+
+    def __init__(self, api_client: ApiClient) -> None:
+        self._api = TermsApi(api_client)
+
+    def create(
+        self,
+        *,
+        request: Optional[CreateTermRequest] = None,
+        **kwargs,
+    ) -> TermResponse:
+        """Create a new term.
+
+        Args:
+            request: Pre-built ``CreateTermRequest``. If provided, all
+                other arguments are ignored.
+            **kwargs: Fields forwarded to ``CreateTermRequest``
+                (e.g. ``sort_id``, ``features``).
+
+        Returns:
+            The created term wrapped in a ``TermResponse``.
+        """
+        if request is None:
+            if "features" in kwargs:
+                kwargs["features"] = _coerce_features(kwargs["features"])
+            request = CreateTermRequest(**kwargs)
+        return self._api.add_term(create_term_request=request)
+
+    def get(self, id: UUID) -> TermResponse:
+        """Get a term by ID."""
+        return self._api.get_term(id=id)
+
+    def list(self) -> TermListResponse:
+        """List all terms for the authenticated tenant."""
+        return self._api.list_terms()
+
+    def exists(self, id: UUID) -> TermExistsResponse:
+        """Check whether a term exists."""
+        return self._api.term_exists(id=id)
+
+    def update(
+        self,
+        id: UUID,
+        *,
+        request: Optional[UpdateTermRequest] = None,
+        **kwargs,
+    ) -> TermResponse:
+        """Update an existing term.
+
+        Args:
+            id: Term ID.
+            request: Pre-built ``UpdateTermRequest``. If provided, all
+                other arguments are ignored.
+            **kwargs: Fields forwarded to ``UpdateTermRequest``.
+
+        Returns:
+            The updated term wrapped in a ``TermResponse``.
+        """
+        if request is None:
+            if "features" in kwargs:
+                kwargs["features"] = _coerce_features(kwargs["features"])
+            request = UpdateTermRequest(**kwargs)
+        return self._api.update_term(id=id, update_term_request=request)
+
+    def delete(self, id: UUID) -> None:
+        """Delete a term by ID."""
+        return self._api.delete_term(id=id)
+
+    def bulk_create(
+        self,
+        *,
+        request: Optional[BulkAddTermsRequest] = None,
+        **kwargs,
+    ) -> BulkAddTermsResponse:
+        """Create multiple terms in a single batch.
+
+        Args:
+            request: Pre-built ``BulkAddTermsRequest``. If provided, all
+                other arguments are ignored.
+            **kwargs: Fields forwarded to ``BulkAddTermsRequest``.
+
+        Returns:
+            A ``BulkAddTermsResponse``.
+        """
+        if request is None:
+            request = BulkAddTermsRequest(**kwargs)
+        return self._api.bulk_add_terms(bulk_add_terms_request=request)
+
+    def clear(self) -> ClearTermsResponse:
+        """Clear **all** terms for the authenticated tenant.
+
+        Warning:
+            This is a destructive operation — use with care.
+        """
+        return self._api.clear_terms()

reasoning_layer_python_sdk/resources/types.py

@@ -0,0 +1,45 @@
+from uuid import UUID
+
+from ..generated.api.types_api import TypesApi
+from ..generated.api_client import ApiClient
+
+
+class TypesClient:
+    """Client for sort/type operations."""
+
+    def __init__(self, api_client: ApiClient) -> None:
+        self._api = TypesApi(api_client)
+
+    def batch_compare_sorts(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.batch_sort_compare_request import (
+                BatchSortCompareRequest,
+            )
+
+            request = BatchSortCompareRequest(**kwargs)
+        return self._api.batch_compare_sorts(batch_sort_compare_request=request)
+
+    def compare_sorts(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.sort_compare_request import SortCompareRequest
+
+            request = SortCompareRequest(**kwargs)
+        return self._api.compare_sorts(sort_compare_request=request)
+
+    def get_greatest_sorts(self, tenant_id: UUID):
+        return self._api.get_greatest_sorts(tenant_id=tenant_id)
+
+    def get_least_sorts(self, tenant_id: UUID):
+        return self._api.get_least_sorts(tenant_id=tenant_id)
+
+    def get_sort_ancestors(self, sort_id: str):
+        return self._api.get_sort_ancestors(id=sort_id)
+
+    def get_sort_children(self, sort_id: str):
+        return self._api.get_sort_children(id=sort_id)
+
+    def get_sort_descendants(self, sort_id: str):
+        return self._api.get_sort_descendants(id=sort_id)
+
+    def get_sort_parents(self, sort_id: str):
+        return self._api.get_sort_parents(id=sort_id)

reasoning_layer_python_sdk/resources/ui.py

@@ -0,0 +1,33 @@
+from ..generated.api.ui_api import UiApi
+from ..generated.api_client import ApiClient
+
+
+class UiClient:
+    """Client for UI operations."""
+
+    def __init__(self, api_client: ApiClient) -> None:
+        self._api = UiApi(api_client)
+
+    def describe(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.ui_describe_request import UIDescribeRequest
+
+            request = UIDescribeRequest(**kwargs)
+        return self._api.describe_ui(ui_describe_request=request)
+
+    def describe_stream(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.ui_describe_request import UIDescribeRequest
+
+            request = UIDescribeRequest(**kwargs)
+        return self._api.describe_ui_stream(ui_describe_request=request)
+
+    def execute_action(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.ui_action_request import UIActionRequest
+
+            request = UIActionRequest(**kwargs)
+        return self._api.execute_ui_action(ui_action_request=request)
+
+    def catalog(self):
+        return self._api.ui_catalog()

reasoning_layer_python_sdk/resources/visualization.py

@@ -0,0 +1,69 @@
+from uuid import UUID
+
+from ..generated.api.visualization_api import VisualizationApi
+from ..generated.api_client import ApiClient
+
+
+class VisualizationClient:
+    """Client for visualization operations."""
+
+    def __init__(self, api_client: ApiClient) -> None:
+        self._api = VisualizationApi(api_client)
+
+    def get_constraint_graph(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.constraint_graph_request import (
+                ConstraintGraphRequest,
+            )
+
+            request = ConstraintGraphRequest(**kwargs)
+        return self._api.get_constraint_graph(constraint_graph_request=request)
+
+    def get_hypergraph(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.hypergraph_request import HypergraphRequest
+
+            request = HypergraphRequest(**kwargs)
+        return self._api.get_hypergraph(hypergraph_request=request)
+
+    def get_lattice_dot(self):
+        return self._api.get_lattice_dot()
+
+    def get_lattice_visualization(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.lattice_visualization_request import (
+                LatticeVisualizationRequest,
+            )
+
+            request = LatticeVisualizationRequest(**kwargs)
+        return self._api.get_lattice_visualization(
+            lattice_visualization_request=request
+        )
+
+    def get_residuation_state(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.residuation_state_request import (
+                ResiduationStateRequest,
+            )
+
+            request = ResiduationStateRequest(**kwargs)
+        return self._api.get_residuation_state(residuation_state_request=request)
+
+    def get_term_subgraph(self, term_id: UUID):
+        return self._api.get_term_subgraph(term_id=term_id)
+
+    def get_trigger_dependencies(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.trigger_dependency_request import (
+                TriggerDependencyRequest,
+            )
+
+            request = TriggerDependencyRequest(**kwargs)
+        return self._api.get_trigger_dependencies(trigger_dependency_request=request)
+
+    def glb_lub_trace(self, *, request=None, **kwargs):
+        if request is None:
+            from ..generated.models.glb_lub_trace_request import GlbLubTraceRequest
+
+            request = GlbLubTraceRequest(**kwargs)
+        return self._api.glb_lub_trace(glb_lub_trace_request=request)

reasoning_layer_python_sdk/resources/webhook_actions.py

@@ -0,0 +1,51 @@
+from uuid import UUID
+
+from ..generated.api.webhook_actions_api import WebhookActionsApi
+from ..generated.api_client import ApiClient
+
+
+class WebhookActionsClient:
+    """Client for webhook action operations."""
+
+    def __init__(self, api_client: ApiClient) -> None:
+        self._api = WebhookActionsApi(api_client)
+
+    def complete_invocation(self, invocation_id: str, *, request=None, **kwargs):
+        """Complete a webhook invocation."""
+        if request is None:
+            from ..generated.models.webhook_callback_request import (
+                WebhookCallbackRequest,
+            )
+
+            request = WebhookCallbackRequest(**kwargs)
+        return self._api.complete_invocation(
+            id=invocation_id, webhook_callback_request=request
+        )
+
+    def invoke(self, name: str, *, request=None, **kwargs):
+        """Invoke an external action."""
+        if request is None:
+            from ..generated.models.invoke_action_request import InvokeActionRequest
+
+            request = InvokeActionRequest(**kwargs)
+        return self._api.invoke_action(name=name, invoke_action_request=request)
+
+    def list_external_actions(self, tenant_id: UUID):
+        """List external actions for a tenant."""
+        return self._api.list_external_actions(tenant_id=tenant_id)
+
+    def list_pending_invocations(self, tenant_id: UUID):
+        """List pending invocations for a tenant."""
+        return self._api.list_pending_invocations(tenant_id=tenant_id)
+
+    def register_external_action(self, *, request=None, **kwargs):
+        """Register an external action."""
+        if request is None:
+            from ..generated.models.register_external_action_request import (
+                RegisterExternalActionRequest,
+            )
+
+            request = RegisterExternalActionRequest(**kwargs)
+        return self._api.register_external_action(
+            register_external_action_request=request
+        )