reasoning_layer_python_sdk 1.0.0__py3-none-any.whl

reasoning_layer_python_sdk/generated/models/formal_judge_response.py

@@ -0,0 +1,187 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from reasoning_layer_python_sdk.generated.models.agent_sub_verdict_dto import AgentSubVerdictDto
+from reasoning_layer_python_sdk.generated.models.certificate_dto import CertificateDto
+from reasoning_layer_python_sdk.generated.models.extraction_stats_dto import ExtractionStatsDto
+from reasoning_layer_python_sdk.generated.models.fix_suggestion_dto import FixSuggestionDto
+from reasoning_layer_python_sdk.generated.models.layer_result_dto import LayerResultDto
+from reasoning_layer_python_sdk.generated.models.proof_trace_dto import ProofTraceDto
+from reasoning_layer_python_sdk.generated.models.violation_dto import ViolationDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class FormalJudgeResponse(BaseModel):
+    """
+    Response from the FormalJudge oversight pipeline.
+    """ # noqa: E501
+    agent_sub_verdicts: Optional[List[AgentSubVerdictDto]] = Field(default=None, description="Per-agent sub-verdicts for multi-agent trajectories (Gap 4). Empty for single-agent trajectories.")
+    certificate: Optional[CertificateDto] = Field(default=None, description="Full validity certificate with per-layer attestations (if safe and enabled). Replaces the flat `certificate_hash` with structured cryptographic proof.")
+    certificate_hash: Optional[StrictStr] = Field(default=None, description="Merkle root hash of the validity certificate (if safe) — kept for backward compat.")
+    deception_fact_map: Optional[Dict[str, StrictBool]] = Field(default=None, description="Deception fact map: all 25 atomic deception facts (paper Table 6) with boolean answers. Keys are fact type names (e.g., \"ToolCallAttempted\", \"FabricatedContent\"), values are true/false for each atomic fact.")
+    detected_deception_predicates: Optional[List[StrictStr]] = Field(default=None, description="Deception predicates that triggered (paper §B.6: φ1-φ4)")
+    elapsed_ms: Annotated[int, Field(strict=True, ge=0)] = Field(description="Processing time in milliseconds")
+    extraction_stats: ExtractionStatsDto = Field(description="Extraction statistics (deterministic vs. semantic)")
+    fabrications_detected: Annotated[int, Field(strict=True, ge=0)] = Field(description="Number of fabricated facts detected")
+    faithfulness_score: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Faithfulness/deception detection score (if enabled)")
+    fix_suggestions: List[FixSuggestionDto] = Field(description="Actionable fix suggestions for violations")
+    is_deceptive: Optional[StrictBool] = Field(default=None, description="Whether the master deception predicate Φ_deceptive triggered")
+    layer_results: List[LayerResultDto] = Field(description="Per-layer verification results")
+    overall_score: Union[StrictFloat, StrictInt] = Field(description="Overall aggregated score (T-norm of layer scores, 0.0-1.0)")
+    proof_traces: Optional[List[ProofTraceDto]] = Field(default=None, description="Failed proof traces with causal chains for violated constraints. Each trace explains WHY a constraint failed, at what depth, and suggests fixes.")
+    verdict: StrictStr = Field(description="Overall verdict: \"safe\", \"unsafe\", \"partial\", or \"residuated\"")
+    violations: List[ViolationDto] = Field(description="Specific constraint violations (if any)")
+    __properties: ClassVar[List[str]] = ["agent_sub_verdicts", "certificate", "certificate_hash", "deception_fact_map", "detected_deception_predicates", "elapsed_ms", "extraction_stats", "fabrications_detected", "faithfulness_score", "fix_suggestions", "is_deceptive", "layer_results", "overall_score", "proof_traces", "verdict", "violations"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of FormalJudgeResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in agent_sub_verdicts (list)
+        _items = []
+        if self.agent_sub_verdicts:
+            for _item_agent_sub_verdicts in self.agent_sub_verdicts:
+                if _item_agent_sub_verdicts:
+                    _items.append(_item_agent_sub_verdicts.to_dict())
+            _dict['agent_sub_verdicts'] = _items
+        # override the default output from pydantic by calling `to_dict()` of certificate
+        if self.certificate:
+            _dict['certificate'] = self.certificate.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of extraction_stats
+        if self.extraction_stats:
+            _dict['extraction_stats'] = self.extraction_stats.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in fix_suggestions (list)
+        _items = []
+        if self.fix_suggestions:
+            for _item_fix_suggestions in self.fix_suggestions:
+                if _item_fix_suggestions:
+                    _items.append(_item_fix_suggestions.to_dict())
+            _dict['fix_suggestions'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in layer_results (list)
+        _items = []
+        if self.layer_results:
+            for _item_layer_results in self.layer_results:
+                if _item_layer_results:
+                    _items.append(_item_layer_results.to_dict())
+            _dict['layer_results'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in proof_traces (list)
+        _items = []
+        if self.proof_traces:
+            for _item_proof_traces in self.proof_traces:
+                if _item_proof_traces:
+                    _items.append(_item_proof_traces.to_dict())
+            _dict['proof_traces'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in violations (list)
+        _items = []
+        if self.violations:
+            for _item_violations in self.violations:
+                if _item_violations:
+                    _items.append(_item_violations.to_dict())
+            _dict['violations'] = _items
+        # set to None if certificate (nullable) is None
+        # and model_fields_set contains the field
+        if self.certificate is None and "certificate" in self.model_fields_set:
+            _dict['certificate'] = None
+
+        # set to None if certificate_hash (nullable) is None
+        # and model_fields_set contains the field
+        if self.certificate_hash is None and "certificate_hash" in self.model_fields_set:
+            _dict['certificate_hash'] = None
+
+        # set to None if faithfulness_score (nullable) is None
+        # and model_fields_set contains the field
+        if self.faithfulness_score is None and "faithfulness_score" in self.model_fields_set:
+            _dict['faithfulness_score'] = None
+
+        # set to None if is_deceptive (nullable) is None
+        # and model_fields_set contains the field
+        if self.is_deceptive is None and "is_deceptive" in self.model_fields_set:
+            _dict['is_deceptive'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FormalJudgeResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "agent_sub_verdicts": [AgentSubVerdictDto.from_dict(_item) for _item in obj["agent_sub_verdicts"]] if obj.get("agent_sub_verdicts") is not None else None,
+            "certificate": CertificateDto.from_dict(obj["certificate"]) if obj.get("certificate") is not None else None,
+            "certificate_hash": obj.get("certificate_hash"),
+            "deception_fact_map": obj.get("deception_fact_map"),
+            "detected_deception_predicates": obj.get("detected_deception_predicates"),
+            "elapsed_ms": obj.get("elapsed_ms"),
+            "extraction_stats": ExtractionStatsDto.from_dict(obj["extraction_stats"]) if obj.get("extraction_stats") is not None else None,
+            "fabrications_detected": obj.get("fabrications_detected"),
+            "faithfulness_score": obj.get("faithfulness_score"),
+            "fix_suggestions": [FixSuggestionDto.from_dict(_item) for _item in obj["fix_suggestions"]] if obj.get("fix_suggestions") is not None else None,
+            "is_deceptive": obj.get("is_deceptive"),
+            "layer_results": [LayerResultDto.from_dict(_item) for _item in obj["layer_results"]] if obj.get("layer_results") is not None else None,
+            "overall_score": obj.get("overall_score"),
+            "proof_traces": [ProofTraceDto.from_dict(_item) for _item in obj["proof_traces"]] if obj.get("proof_traces") is not None else None,
+            "verdict": obj.get("verdict"),
+            "violations": [ViolationDto.from_dict(_item) for _item in obj["violations"]] if obj.get("violations") is not None else None
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/formal_verdict_dto.py

@@ -0,0 +1,107 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Union
+from typing_extensions import Annotated
+from reasoning_layer_python_sdk.generated.models.layer_result_summary_dto import LayerResultSummaryDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class FormalVerdictDto(BaseModel):
+    """
+    FormalJudge semantic verification verdict. Only present when an LLM is configured and semantic verification was performed.
+    """ # noqa: E501
+    confidence: Union[StrictFloat, StrictInt] = Field(description="Overall score (0.0 to 1.0)")
+    deterministic_facts: Annotated[int, Field(strict=True, ge=0)] = Field(description="Number of deterministic facts checked (no LLM)")
+    layer_results: List[LayerResultSummaryDto] = Field(description="Per-layer verification summaries")
+    overall_verdict: StrictStr = Field(description="Overall verdict: \"safe\", \"unsafe\", \"partial\", or \"residuated\"")
+    semantic_facts: Annotated[int, Field(strict=True, ge=0)] = Field(description="Number of semantic facts checked (with LLM)")
+    total_llm_calls: Annotated[int, Field(strict=True, ge=0)] = Field(description="Total LLM calls made")
+    __properties: ClassVar[List[str]] = ["confidence", "deterministic_facts", "layer_results", "overall_verdict", "semantic_facts", "total_llm_calls"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of FormalVerdictDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in layer_results (list)
+        _items = []
+        if self.layer_results:
+            for _item_layer_results in self.layer_results:
+                if _item_layer_results:
+                    _items.append(_item_layer_results.to_dict())
+            _dict['layer_results'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FormalVerdictDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "confidence": obj.get("confidence"),
+            "deterministic_facts": obj.get("deterministic_facts"),
+            "layer_results": [LayerResultSummaryDto.from_dict(_item) for _item in obj["layer_results"]] if obj.get("layer_results") is not None else None,
+            "overall_verdict": obj.get("overall_verdict"),
+            "semantic_facts": obj.get("semantic_facts"),
+            "total_llm_calls": obj.get("total_llm_calls")
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/forward_chain_request.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from reasoning_layer_python_sdk.generated.models.term_input_dto import TermInputDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ForwardChainRequest(BaseModel):
+    """
+    Request for forward chaining.
+    """ # noqa: E501
+    enable_provenance_tags: Optional[StrictBool] = Field(default=None, description="Enable provenance tag propagation alongside symbolic forward chaining. When true, each derived fact gets a confidence tag via the probabilistic semiring. The symbolic engine decides WHICH facts are derivable; tags only decide WEIGHTS. Default: false (standard symbolic-only forward chaining)")
+    initial_facts: Optional[List[TermInputDto]] = Field(default=None, description="Initial facts (optional - uses existing facts if not provided)")
+    max_facts: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=100000, description="Maximum facts to derive")
+    max_iterations: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=1000, description="Maximum iterations")
+    persist_derived: Optional[StrictBool] = Field(default=None, description="TRUE HOMOICONICITY: Persist derived facts to PostgreSQL and add to homoiconic_rules. When true, derived facts become permanent facts/rules that survive server restart and are available for backward chaining. Default: false (derived facts are ephemeral, returned but not persisted)")
+    __properties: ClassVar[List[str]] = ["enable_provenance_tags", "initial_facts", "max_facts", "max_iterations", "persist_derived"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ForwardChainRequest from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in initial_facts (list)
+        _items = []
+        if self.initial_facts:
+            for _item_initial_facts in self.initial_facts:
+                if _item_initial_facts:
+                    _items.append(_item_initial_facts.to_dict())
+            _dict['initial_facts'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ForwardChainRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "enable_provenance_tags": obj.get("enable_provenance_tags"),
+            "initial_facts": [TermInputDto.from_dict(_item) for _item in obj["initial_facts"]] if obj.get("initial_facts") is not None else None,
+            "max_facts": obj.get("max_facts") if obj.get("max_facts") is not None else 100000,
+            "max_iterations": obj.get("max_iterations") if obj.get("max_iterations") is not None else 1000,
+            "persist_derived": obj.get("persist_derived")
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/forward_chain_response.py

@@ -0,0 +1,117 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from reasoning_layer_python_sdk.generated.models.provenance_tag_dto import ProvenanceTagDto
+from reasoning_layer_python_sdk.generated.models.psi_term_dto import PsiTermDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ForwardChainResponse(BaseModel):
+    """
+    Response for forward chaining.
+    """ # noqa: E501
+    derived_count: Annotated[int, Field(strict=True, ge=0)] = Field(description="Number of newly derived facts")
+    derived_facts: List[PsiTermDto] = Field(description="Derived facts (as terms)")
+    iterations: Annotated[int, Field(strict=True, ge=0)] = Field(description="Number of iterations performed")
+    materialization_time_ms: Annotated[int, Field(strict=True, ge=0)] = Field(description="Materialization time in milliseconds")
+    persisted_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="TRUE HOMOICONICITY: Number of derived facts persisted to PostgreSQL (only populated when persist_derived=true in request)")
+    provenance_tags: Optional[List[ProvenanceTagDto]] = Field(default=None, description="Provenance tags for derived facts (only populated when enable_provenance_tags=true). Each tag maps a derived fact (by index into derived_facts) to its confidence score.")
+    total_facts: Annotated[int, Field(strict=True, ge=0)] = Field(description="Total facts after materialization")
+    __properties: ClassVar[List[str]] = ["derived_count", "derived_facts", "iterations", "materialization_time_ms", "persisted_count", "provenance_tags", "total_facts"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ForwardChainResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in derived_facts (list)
+        _items = []
+        if self.derived_facts:
+            for _item_derived_facts in self.derived_facts:
+                if _item_derived_facts:
+                    _items.append(_item_derived_facts.to_dict())
+            _dict['derived_facts'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in provenance_tags (list)
+        _items = []
+        if self.provenance_tags:
+            for _item_provenance_tags in self.provenance_tags:
+                if _item_provenance_tags:
+                    _items.append(_item_provenance_tags.to_dict())
+            _dict['provenance_tags'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ForwardChainResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "derived_count": obj.get("derived_count"),
+            "derived_facts": [PsiTermDto.from_dict(_item) for _item in obj["derived_facts"]] if obj.get("derived_facts") is not None else None,
+            "iterations": obj.get("iterations"),
+            "materialization_time_ms": obj.get("materialization_time_ms"),
+            "persisted_count": obj.get("persisted_count"),
+            "provenance_tags": [ProvenanceTagDto.from_dict(_item) for _item in obj["provenance_tags"]] if obj.get("provenance_tags") is not None else None,
+            "total_facts": obj.get("total_facts")
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/function_body_dto.py

@@ -0,0 +1,151 @@
+# coding: utf-8
+
+"""
+    OSF Knowledge Base API
+
+    Order-Sorted Feature logic knowledge base with fuzzy reasoning, inference, and constraint solving. Note: Some endpoints are hidden from Swagger due to recursive type limitations but work via API calls.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+import pprint
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
+from typing import Any, List, Optional
+from reasoning_layer_python_sdk.generated.models.expression_dto_one_of3 import ExpressionDtoOneOf3
+from reasoning_layer_python_sdk.generated.models.function_body_dto_one_of import FunctionBodyDtoOneOf
+from reasoning_layer_python_sdk.generated.models.function_body_dto_one_of1 import FunctionBodyDtoOneOf1
+from pydantic import StrictStr, Field
+from typing import Union, List, Set, Optional, Dict
+from typing_extensions import Literal, Self
+
+FUNCTIONBODYDTO_ONE_OF_SCHEMAS = ["ExpressionDtoOneOf3", "FunctionBodyDtoOneOf", "FunctionBodyDtoOneOf1"]
+
+class FunctionBodyDto(BaseModel):
+    """
+    Function body - what to compute
+    """
+    # data type: FunctionBodyDtoOneOf
+    oneof_schema_1_validator: Optional[FunctionBodyDtoOneOf] = None
+    # data type: FunctionBodyDtoOneOf1
+    oneof_schema_2_validator: Optional[FunctionBodyDtoOneOf1] = None
+    # data type: ExpressionDtoOneOf3
+    oneof_schema_3_validator: Optional[ExpressionDtoOneOf3] = None
+    actual_instance: Optional[Union[ExpressionDtoOneOf3, FunctionBodyDtoOneOf, FunctionBodyDtoOneOf1]] = None
+    one_of_schemas: Set[str] = { "ExpressionDtoOneOf3", "FunctionBodyDtoOneOf", "FunctionBodyDtoOneOf1" }
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator('actual_instance')
+    def actual_instance_must_validate_oneof(cls, v):
+        instance = FunctionBodyDto.model_construct()
+        error_messages = []
+        match = 0
+        # validate data type: FunctionBodyDtoOneOf
+        if not isinstance(v, FunctionBodyDtoOneOf):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `FunctionBodyDtoOneOf`")
+        else:
+            match += 1
+        # validate data type: FunctionBodyDtoOneOf1
+        if not isinstance(v, FunctionBodyDtoOneOf1):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `FunctionBodyDtoOneOf1`")
+        else:
+            match += 1
+        # validate data type: ExpressionDtoOneOf3
+        if not isinstance(v, ExpressionDtoOneOf3):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `ExpressionDtoOneOf3`")
+        else:
+            match += 1
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when setting `actual_instance` in FunctionBodyDto with oneOf schemas: ExpressionDtoOneOf3, FunctionBodyDtoOneOf, FunctionBodyDtoOneOf1. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when setting `actual_instance` in FunctionBodyDto with oneOf schemas: ExpressionDtoOneOf3, FunctionBodyDtoOneOf, FunctionBodyDtoOneOf1. Details: " + ", ".join(error_messages))
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        match = 0
+
+        # deserialize data into FunctionBodyDtoOneOf
+        try:
+            instance.actual_instance = FunctionBodyDtoOneOf.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into FunctionBodyDtoOneOf1
+        try:
+            instance.actual_instance = FunctionBodyDtoOneOf1.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into ExpressionDtoOneOf3
+        try:
+            instance.actual_instance = ExpressionDtoOneOf3.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when deserializing the JSON string into FunctionBodyDto with oneOf schemas: ExpressionDtoOneOf3, FunctionBodyDtoOneOf, FunctionBodyDtoOneOf1. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into FunctionBodyDto with oneOf schemas: ExpressionDtoOneOf3, FunctionBodyDtoOneOf, FunctionBodyDtoOneOf1. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], ExpressionDtoOneOf3, FunctionBodyDtoOneOf, FunctionBodyDtoOneOf1]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            # primitive type
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
+
+