reasoning_layer_python_sdk 1.0.0__py3-none-any.whl

reasoning_layer_python_sdk/generated/models/proof_dto.py

@@ -0,0 +1,110 @@
+# 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
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from uuid import UUID
+from reasoning_layer_python_sdk.generated.models.homoiconic_substitution_dto import HomoiconicSubstitutionDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProofDto(BaseModel):
+    """
+    A proof tree node showing how a goal was proven. Contains goal_term_id, optional rule_term_id, subproofs (recursive), substitution, and certainty.
+    """ # noqa: E501
+    certainty: Union[StrictFloat, StrictInt]
+    goal_term_id: UUID
+    rule_term_id: Optional[UUID] = None
+    subproofs: Optional[List[ProofDto]] = Field(default=None, description="Child proof nodes (recursive)")
+    substitution: HomoiconicSubstitutionDto
+    __properties: ClassVar[List[str]] = ["certainty", "goal_term_id", "rule_term_id", "subproofs", "substitution"]
+
+    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 ProofDto 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 subproofs (list)
+        _items = []
+        if self.subproofs:
+            for _item_subproofs in self.subproofs:
+                if _item_subproofs:
+                    _items.append(_item_subproofs.to_dict())
+            _dict['subproofs'] = _items
+        # override the default output from pydantic by calling `to_dict()` of substitution
+        if self.substitution:
+            _dict['substitution'] = self.substitution.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProofDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "certainty": obj.get("certainty"),
+            "goal_term_id": obj.get("goal_term_id"),
+            "rule_term_id": obj.get("rule_term_id"),
+            "subproofs": [ProofDto.from_dict(_item) for _item in obj["subproofs"]] if obj.get("subproofs") is not None else None,
+            "substitution": HomoiconicSubstitutionDto.from_dict(obj["substitution"]) if obj.get("substitution") is not None else None
+        })
+        return _obj
+
+# TODO: Rewrite to not use raise_errors
+ProofDto.model_rebuild(raise_errors=False)
+

reasoning_layer_python_sdk/generated/models/proof_node_dto.py

@@ -0,0 +1,113 @@
+# 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, Optional, Union
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProofNodeDto(BaseModel):
+    """
+    A node in the causal proof tree
+    """ # noqa: E501
+    certainty: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Certainty at this step")
+    children: List[StrictStr] = Field(description="Child node IDs")
+    depth: Annotated[int, Field(strict=True, ge=0)] = Field(description="Depth in the proof tree")
+    explanation: StrictStr = Field(description="Human-readable explanation")
+    id: StrictStr = Field(description="Unique identifier for this node")
+    parent_id: Optional[StrictStr] = Field(default=None, description="Parent node ID (if any)")
+    rule_name: StrictStr = Field(description="Rule name or constraint that justified this step")
+    step_type: StrictStr = Field(description="Type of proof step")
+    __properties: ClassVar[List[str]] = ["certainty", "children", "depth", "explanation", "id", "parent_id", "rule_name", "step_type"]
+
+    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 ProofNodeDto 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,
+        )
+        # set to None if certainty (nullable) is None
+        # and model_fields_set contains the field
+        if self.certainty is None and "certainty" in self.model_fields_set:
+            _dict['certainty'] = None
+
+        # set to None if parent_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.parent_id is None and "parent_id" in self.model_fields_set:
+            _dict['parent_id'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProofNodeDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "certainty": obj.get("certainty"),
+            "children": obj.get("children"),
+            "depth": obj.get("depth"),
+            "explanation": obj.get("explanation"),
+            "id": obj.get("id"),
+            "parent_id": obj.get("parent_id"),
+            "rule_name": obj.get("rule_name"),
+            "step_type": obj.get("step_type")
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/proof_statistics_dto.py

@@ -0,0 +1,100 @@
+# 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 typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProofStatisticsDto(BaseModel):
+    """
+    Proof tree statistics
+    """ # noqa: E501
+    duration_ms: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Duration in milliseconds")
+    max_depth: Annotated[int, Field(strict=True, ge=0)] = Field(description="Maximum depth reached")
+    rules_applied: Annotated[int, Field(strict=True, ge=0)] = Field(description="Number of rules applied")
+    total_nodes: Annotated[int, Field(strict=True, ge=0)] = Field(description="Total nodes in proof")
+    __properties: ClassVar[List[str]] = ["duration_ms", "max_depth", "rules_applied", "total_nodes"]
+
+    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 ProofStatisticsDto 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,
+        )
+        # set to None if duration_ms (nullable) is None
+        # and model_fields_set contains the field
+        if self.duration_ms is None and "duration_ms" in self.model_fields_set:
+            _dict['duration_ms'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProofStatisticsDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "duration_ms": obj.get("duration_ms"),
+            "max_depth": obj.get("max_depth"),
+            "rules_applied": obj.get("rules_applied"),
+            "total_nodes": obj.get("total_nodes")
+        })
+        return _obj
+
+

reasoning_layer_python_sdk/generated/models/proof_trace_dto.py

@@ -0,0 +1,113 @@
+# 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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from reasoning_layer_python_sdk.generated.models.fix_suggestion_dto import FixSuggestionDto
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProofTraceDto(BaseModel):
+    """
+    A failed proof trace with causal chain. Explains WHY a constraint failed, the proof depth, and nested causes.
+    """ # noqa: E501
+    depth: StrictInt = Field(description="Depth at which failure occurred in the proof tree")
+    failure_details: StrictStr = Field(description="Detailed reason description")
+    failure_point: Optional[StrictStr] = Field(default=None, description="The specific term where failure occurred (if applicable)")
+    failure_reason: StrictStr = Field(description="Why the proof failed (human-readable classification)")
+    goal_term_ids: List[StrictStr] = Field(description="The goal terms that couldn't be proved")
+    parent: Optional[ProofTraceDto] = None
+    suggestions: List[FixSuggestionDto] = Field(description="Suggested fixes from the proof engine")
+    __properties: ClassVar[List[str]] = ["depth", "failure_details", "failure_point", "failure_reason", "goal_term_ids", "parent", "suggestions"]
+
+    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 ProofTraceDto 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 parent
+        if self.parent:
+            _dict['parent'] = self.parent.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in suggestions (list)
+        _items = []
+        if self.suggestions:
+            for _item_suggestions in self.suggestions:
+                if _item_suggestions:
+                    _items.append(_item_suggestions.to_dict())
+            _dict['suggestions'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProofTraceDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "depth": obj.get("depth"),
+            "failure_details": obj.get("failure_details"),
+            "failure_point": obj.get("failure_point"),
+            "failure_reason": obj.get("failure_reason"),
+            "goal_term_ids": obj.get("goal_term_ids"),
+            "parent": ProofTraceDto.from_dict(obj["parent"]) if obj.get("parent") is not None else None,
+            "suggestions": [FixSuggestionDto.from_dict(_item) for _item in obj["suggestions"]] if obj.get("suggestions") is not None else None
+        })
+        return _obj
+
+# TODO: Rewrite to not use raise_errors
+ProofTraceDto.model_rebuild(raise_errors=False)
+

reasoning_layer_python_sdk/generated/models/proof_trace_node_dto.py

@@ -0,0 +1,109 @@
+# 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, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProofTraceNodeDto(BaseModel):
+    """
+    ProofTraceNodeDto
+    """ # noqa: E501
+    children: Optional[List[ProofTraceNodeDto]] = None
+    confidence: Optional[Union[StrictFloat, StrictInt]] = None
+    detail: Optional[StrictStr] = None
+    id: StrictStr
+    label: StrictStr
+    node_type: StrictStr
+    rule: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["children", "confidence", "detail", "id", "label", "node_type", "rule"]
+
+    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 ProofTraceNodeDto 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 children (list)
+        _items = []
+        if self.children:
+            for _item_children in self.children:
+                if _item_children:
+                    _items.append(_item_children.to_dict())
+            _dict['children'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProofTraceNodeDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "children": [ProofTraceNodeDto.from_dict(_item) for _item in obj["children"]] if obj.get("children") is not None else None,
+            "confidence": obj.get("confidence"),
+            "detail": obj.get("detail"),
+            "id": obj.get("id"),
+            "label": obj.get("label"),
+            "node_type": obj.get("node_type"),
+            "rule": obj.get("rule")
+        })
+        return _obj
+
+# TODO: Rewrite to not use raise_errors
+ProofTraceNodeDto.model_rebuild(raise_errors=False)
+

reasoning_layer_python_sdk/generated/models/proposed_factor_dto.py

@@ -0,0 +1,90 @@
+# 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, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class ProposedFactorDto(BaseModel):
+    """
+    A proposed factor of variation.
+    """ # noqa: E501
+    description: StrictStr = Field(description="One-sentence description.")
+    name: StrictStr = Field(description="Factor name (snake_case, becomes a candidate sort local name).")
+    __properties: ClassVar[List[str]] = ["description", "name"]
+
+    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 ProposedFactorDto 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ProposedFactorDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "description": obj.get("description"),
+            "name": obj.get("name")
+        })
+        return _obj
+
+