reasoning_layer_python_sdk 1.4.0__tar.gz → 1.6.0__tar.gz

{reasoning_layer_python_sdk-1.4.0 → reasoning_layer_python_sdk-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reasoning_layer_python_sdk
-Version: 1.4.0
+Version: 1.6.0
 Summary: A simple SDK package built in python for the Reasoning Layer tool by Kortexya
 Author: David Loiret, Anexoms
 Author-email: David Loiret <contact@kortexya.com>, Anexoms <maxence.pierre@epitech.eu>

{reasoning_layer_python_sdk-1.4.0 → reasoning_layer_python_sdk-1.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "reasoning_layer_python_sdk"
-version = "1.4.0"
+version = "1.6.0"
 authors = [
   { name="David Loiret", email="contact@kortexya.com" },
   { name="Anexoms", email="maxence.pierre@epitech.eu" },

{reasoning_layer_python_sdk-1.4.0 → reasoning_layer_python_sdk-1.6.0}/src/reasoning_layer_python_sdk/__init__.py

@@ -1,4 +1,4 @@
-from .builders import TermInput, Value
+from .builders import FuzzyShape, TermInput, Value
 from .client import ReasoningLayerClient
 from .config import ClientConfig
 from .errors import ReasoningLayerError
@@ -9,4 +9,5 @@ __all__ = [
     "ReasoningLayerError",
     "TermInput",
     "Value",
+    "FuzzyShape",
 ]

{reasoning_layer_python_sdk-1.4.0 → reasoning_layer_python_sdk-1.6.0}/src/reasoning_layer_python_sdk/builders/__init__.py

@@ -42,6 +42,12 @@ from ..generated.models.string import String
 from ..generated.models.term_input_dto import TermInputDto
 from ..generated.models.uninstantiated import Uninstantiated
 from ..generated.models.value_dto import ValueDto
+from ..generated.models.fuzzy_shape_dto import FuzzyShapeDto
+from ..generated.models.fuzzy_shape_dto_one_of import FuzzyShapeDtoOneOf
+from ..generated.models.fuzzy_shape_dto_one_of2 import FuzzyShapeDtoOneOf2
+from ..generated.models.fuzzy_shape_dto_one_of4 import FuzzyShapeDtoOneOf4
+from ..generated.models.fuzzy_shape_dto_one_of5 import FuzzyShapeDtoOneOf5
+from ..generated.models.fuzzy_shape_dto_one_of6 import FuzzyShapeDtoOneOf6
 
 
 class Value:
@@ -164,6 +170,79 @@ def _coerce_inline_features(
     return {k: _coerce_inline_feature(v) for k, v in features.items()}
 
 
+class FuzzyShape:
+    """Convenience builders for fuzzy membership functions.
+
+    Wraps the generated Pydantic models so you can write::
+
+        reliability = FuzzyShape.gaussian(0.7, 0.15)
+    """
+
+    @staticmethod
+    def triangular(a: float, b: float, c: float) -> ValueDto:
+        return Value.fuzzy_number(
+            FuzzyNumberValue(
+                shape=FuzzyShapeDto(
+                    actual_instance=FuzzyShapeDtoOneOf(kind="Triangular", a=a, b=b, c=c)
+                )
+            )
+        )
+
+    @staticmethod
+    def sigmoid(midpoint: float, steepness: float) -> ValueDto:
+        return Value.fuzzy_number(
+            FuzzyNumberValue(
+                shape=FuzzyShapeDto(
+                    actual_instance=FuzzyShapeDtoOneOf4(
+                        kind="Sigmoid", midpoint=midpoint, steepness=steepness
+                    )
+                )
+            )
+        )
+
+    @staticmethod
+    def bell(center: float, width: float, slope: float) -> ValueDto:
+        return Value.fuzzy_number(
+            FuzzyNumberValue(
+                shape=FuzzyShapeDto(
+                    actual_instance=FuzzyShapeDtoOneOf5(
+                        kind="Bell", center=center, width=width, slope=slope
+                    )
+                )
+            )
+        )
+
+    @staticmethod
+    def sigmoid_difference(
+        midpoint1: float, steepness1: float, midpoint2: float, steepness2: float
+    ) -> ValueDto:
+        return Value.fuzzy_number(
+            FuzzyNumberValue(
+                shape=FuzzyShapeDto(
+                    actual_instance=FuzzyShapeDtoOneOf6(
+                        kind="SigmoidDifference",
+                        midpoint1=midpoint1,
+                        steepness1=steepness1,
+                        midpoint2=midpoint2,
+                        steepness2=steepness2,
+                    )
+                )
+            )
+        )
+
+    @staticmethod
+    def gaussian(mean: float, std_dev: float) -> ValueDto:
+        return Value.fuzzy_number(
+            FuzzyNumberValue(
+                shape=FuzzyShapeDto(
+                    actual_instance=FuzzyShapeDtoOneOf2(
+                        kind="Gaussian", mean=mean, std_dev=std_dev
+                    )
+                )
+            )
+        )
+
+
 class TermInput:
     """Factory for ``TermInputDto`` instances.
 

{reasoning_layer_python_sdk-1.4.0 → reasoning_layer_python_sdk-1.6.0}/src/reasoning_layer_python_sdk/config.py

@@ -2,7 +2,7 @@ import os
 from dataclasses import dataclass
 from typing import Optional
 
-SDK_VERSION = "1.4.0"
+SDK_VERSION = "1.6.0"
 
 
 @dataclass

{reasoning_layer_python_sdk-1.4.0 → reasoning_layer_python_sdk-1.6.0}/src/reasoning_layer_python_sdk/generated/models/feature_value_dto.py

@@ -114,6 +114,11 @@ class FeatureValueDto(BaseModel):
         if json_str is None:
             return instance
 
+        # Fast-path for dict values (term references)
+        parsed = json.loads(json_str)
+        if isinstance(parsed, dict):
+            return cls.model_construct(actual_instance=parsed)
+
         error_messages = []
         match = 0
 

{reasoning_layer_python_sdk-1.4.0 → reasoning_layer_python_sdk-1.6.0}/src/reasoning_layer_python_sdk/generated/models/fuzzy_search_top_k_request.py

@@ -30,10 +30,10 @@ class FuzzySearchTopKRequest(BaseModel):
     """
     Request for top-K similarity search
     """ # noqa: E501
-    term_id: UUID
+    term_id: Optional[UUID] = None
     type: StrictStr
-    features: Dict[str, ValueDto]
-    sort_id: UUID
+    features: Optional[Dict[str, ValueDto]] = None
+    sort_id: Optional[UUID] = None
     fail_on_unknown: Optional[StrictBool] = Field(default=None, description="Whether to fail when encountering unknown (Uninstantiated) values instead of residuating false = enable residuation (default)")
     k: Annotated[int, Field(strict=True, ge=0)] = Field(description="Number of results to return")
     min_degree: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Optional minimum similarity degree")
@@ -43,8 +43,8 @@ class FuzzySearchTopKRequest(BaseModel):
     @field_validator('type')
     def type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in set(['inline']):
-            raise ValueError("must be one of enum values ('inline')")
+        if value not in set(['inline', 'by_id']):
+            raise ValueError("must be one of enum values ('inline', 'by_id')")
         return value
 
     model_config = ConfigDict(

{reasoning_layer_python_sdk-1.4.0 → reasoning_layer_python_sdk-1.6.0}/src/reasoning_layer_python_sdk/generated/models/json_value.py

@@ -47,6 +47,14 @@ class JsonValue(BaseModel):
         protected_namespaces=(),
     )
 
+    @classmethod
+    def model_validate(cls, obj, *, strict=None, from_attributes=None, context=None):
+        """Override to accept plain values directly."""
+        if not isinstance(obj, dict):
+            return cls(actual_instance=obj)
+        return super().model_validate(
+            obj, strict=strict, from_attributes=from_attributes, context=context
+        )
 
     def __init__(self, *args, **kwargs) -> None:
         if args:

{reasoning_layer_python_sdk-1.4.0 → reasoning_layer_python_sdk-1.6.0}/src/reasoning_layer_python_sdk/generated/models/osf_constraint_dto_one_of20.py

@@ -17,7 +17,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List
 from typing import Optional, Set
 from typing_extensions import Self
@@ -27,10 +27,10 @@ class OsfConstraintDtoOneOf20(BaseModel):
     """
     OsfConstraintDtoOneOf20
     """ # noqa: E501
-    copy: StrictStr
+    copy_: StrictStr = Field(alias="copy")
     term: OsfClauseDto
     type: StrictStr
-    __properties: ClassVar[List[str]] = ["copy", "term", "type"]
+    __properties: ClassVar[List[str]] = ["copy_", "term", "type"]
 
     @field_validator('type')
     def type_validate_enum(cls, value):

{reasoning_layer_python_sdk-1.4.0 → reasoning_layer_python_sdk-1.6.0}/src/reasoning_layer_python_sdk/generated/models/value_dto.py

@@ -27,7 +27,7 @@ from reasoning_layer_python_sdk.generated.models.set import Set
 from reasoning_layer_python_sdk.generated.models.string import String
 from reasoning_layer_python_sdk.generated.models.uninstantiated import Uninstantiated
 from pydantic import StrictStr, Field
-from typing import Union, List, Set, Optional, Dict
+from typing import Union, List, Optional, Dict
 from typing_extensions import Literal, Self
 
 VALUEDTO_ONE_OF_SCHEMAS = ["Boolean", "FuzzyNumber", "FuzzyScalar", "Integer", "List", "Real", "Reference1", "Set", "String", "Uninstantiated"]
@@ -49,15 +49,15 @@ class ValueDto(BaseModel):
     # data type: Reference1
     oneof_schema_6_validator: Optional[Reference1] = None
     # data type: List
-    oneof_schema_7_validator: Optional[List] = None
+    oneof_schema_7_validator: Optional[Any] = None
     # data type: FuzzyScalar
     oneof_schema_8_validator: Optional[FuzzyScalar] = None
     # data type: FuzzyNumber
     oneof_schema_9_validator: Optional[FuzzyNumber] = None
     # data type: Set
     oneof_schema_10_validator: Optional[Set] = None
-    actual_instance: Optional[Union[Boolean, FuzzyNumber, FuzzyScalar, Integer, List, Real, Reference1, Set, String, Uninstantiated]] = None
-    one_of_schemas: Set[str] = { "Boolean", "FuzzyNumber", "FuzzyScalar", "Integer", "List", "Real", "Reference1", "Set", "String", "Uninstantiated" }
+    actual_instance: Optional[Any] = None
+    one_of_schemas: set[str] = { "Boolean", "FuzzyNumber", "FuzzyScalar", "Integer", "List", "Real", "Reference1", "Set", "String", "Uninstantiated" }
 
     model_config = ConfigDict(
         validate_assignment=True,
@@ -114,11 +114,10 @@ class ValueDto(BaseModel):
         else:
             match += 1
         # validate data type: List
-        try:
-            instance.oneof_schema_7_validator = v
+        if not isinstance(v, List):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `List`")
+        else:
             match += 1
-        except (ValidationError, ValueError) as e:
-            error_messages.append(str(e))
         # validate data type: FuzzyScalar
         if not isinstance(v, FuzzyScalar):
             error_messages.append(f"Error! Input type `{type(v)}` is not `FuzzyScalar`")
@@ -192,12 +191,9 @@ class ValueDto(BaseModel):
             error_messages.append(str(e))
         # deserialize data into List
         try:
-            # validation
-            instance.oneof_schema_7_validator = json.loads(json_str)
-            # assign value to actual_instance
-            instance.actual_instance = instance.oneof_schema_7_validator
+            instance.actual_instance = List.from_json(json_str)
             match += 1
-        except (ValidationError, ValueError) as e:
+        except Exception as e:
             error_messages.append(str(e))
         # deserialize data into FuzzyScalar
         try:

{reasoning_layer_python_sdk-1.4.0 → reasoning_layer_python_sdk-1.6.0}/src/reasoning_layer_python_sdk/resources/cognitive.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Any, Optional
 from uuid import UUID
 
 from ..generated.api.cognitive_agents_episodic_memory_api import (
@@ -16,6 +16,7 @@ from ..generated.api_client import ApiClient
 from ..generated.models.adaptive_modify_request import AdaptiveModifyRequest
 from ..generated.models.add_belief_request import AddBeliefRequest
 from ..generated.models.add_goal_request import AddGoalRequest
+from ..generated.models.json_value import JsonValue
 from ..generated.models.create_agent_request import CreateAgentRequest
 from ..generated.models.get_agent_state_request import GetAgentStateRequest
 from ..generated.models.provide_feedback_request import ProvideFeedbackRequest
@@ -25,6 +26,26 @@ from ..generated.models.run_integrated_cycle_request import RunIntegratedCycleRe
 from ..generated.models.subscribe_to_kb_request import SubscribeToKbRequest
 
 
+def _wrap_json_values(obj: Any) -> Any:
+    """Recursively wrap plain values inside 'features' dicts as JsonValue."""
+    if isinstance(obj, dict):
+        wrapped = {}
+        for key, value in obj.items():
+            if key == "features" and isinstance(value, dict):
+                wrapped[key] = {
+                    k: JsonValue(v)
+                    if v is not None and not isinstance(v, JsonValue)
+                    else v
+                    for k, v in value.items()
+                }
+            else:
+                wrapped[key] = _wrap_json_values(value)
+        return wrapped
+    if isinstance(obj, list):
+        return [_wrap_json_values(item) for item in obj]
+    return obj
+
+
 class _CognitiveMemoryClient:
     """Episodic memory operations for cognitive agents."""
 
@@ -317,6 +338,7 @@ class CognitiveClient:
     ):
         """Add a belief to an agent."""
         if request is None:
+            kwargs = _wrap_json_values(kwargs)
             request = AddBeliefRequest(**kwargs)
         return self._api.add_belief(add_belief_request=request)
 
@@ -328,6 +350,7 @@ class CognitiveClient:
     ):
         """Add a goal to an agent."""
         if request is None:
+            kwargs = _wrap_json_values(kwargs)
             request = AddGoalRequest(**kwargs)
         return self._api.add_goal(add_goal_request=request)
 
@@ -347,6 +370,7 @@ class CognitiveClient:
                 AddCognitiveRuleRequest,
             )
 
+            kwargs = _wrap_json_values(kwargs)
             request = AddCognitiveRuleRequest(**kwargs)
         return self._api.add_cognitive_rule(add_cognitive_rule_request=request)