hindsight-client 0.0.13__py3-none-any.whl

hindsight_client_api/models/recall_response.py

@@ -0,0 +1,142 @@
+# coding: utf-8
+
+"""
+    Hindsight HTTP API
+
+    HTTP API for Hindsight
+
+    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
+from typing import Any, ClassVar, Dict, List, Optional
+from hindsight_client_api.models.chunk_data import ChunkData
+from hindsight_client_api.models.entity_state_response import EntityStateResponse
+from hindsight_client_api.models.recall_result import RecallResult
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RecallResponse(BaseModel):
+    """
+    Response model for recall endpoints.
+    """ # noqa: E501
+    results: List[RecallResult]
+    trace: Optional[Dict[str, Any]] = None
+    entities: Optional[Dict[str, EntityStateResponse]] = None
+    chunks: Optional[Dict[str, ChunkData]] = None
+    __properties: ClassVar[List[str]] = ["results", "trace", "entities", "chunks"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RecallResponse 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 results (list)
+        _items = []
+        if self.results:
+            for _item_results in self.results:
+                if _item_results:
+                    _items.append(_item_results.to_dict())
+            _dict['results'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each value in entities (dict)
+        _field_dict = {}
+        if self.entities:
+            for _key_entities in self.entities:
+                if self.entities[_key_entities]:
+                    _field_dict[_key_entities] = self.entities[_key_entities].to_dict()
+            _dict['entities'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each value in chunks (dict)
+        _field_dict = {}
+        if self.chunks:
+            for _key_chunks in self.chunks:
+                if self.chunks[_key_chunks]:
+                    _field_dict[_key_chunks] = self.chunks[_key_chunks].to_dict()
+            _dict['chunks'] = _field_dict
+        # set to None if trace (nullable) is None
+        # and model_fields_set contains the field
+        if self.trace is None and "trace" in self.model_fields_set:
+            _dict['trace'] = None
+
+        # set to None if entities (nullable) is None
+        # and model_fields_set contains the field
+        if self.entities is None and "entities" in self.model_fields_set:
+            _dict['entities'] = None
+
+        # set to None if chunks (nullable) is None
+        # and model_fields_set contains the field
+        if self.chunks is None and "chunks" in self.model_fields_set:
+            _dict['chunks'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RecallResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "results": [RecallResult.from_dict(_item) for _item in obj["results"]] if obj.get("results") is not None else None,
+            "trace": obj.get("trace"),
+            "entities": dict(
+                (_k, EntityStateResponse.from_dict(_v))
+                for _k, _v in obj["entities"].items()
+            )
+            if obj.get("entities") is not None
+            else None,
+            "chunks": dict(
+                (_k, ChunkData.from_dict(_v))
+                for _k, _v in obj["chunks"].items()
+            )
+            if obj.get("chunks") is not None
+            else None
+        })
+        return _obj
+
+

hindsight_client_api/models/recall_result.py

@@ -0,0 +1,152 @@
+# coding: utf-8
+
+"""
+    Hindsight HTTP API
+
+    HTTP API for Hindsight
+
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RecallResult(BaseModel):
+    """
+    Single recall result item.
+    """ # noqa: E501
+    id: StrictStr
+    text: StrictStr
+    type: Optional[StrictStr] = None
+    entities: Optional[List[StrictStr]] = None
+    context: Optional[StrictStr] = None
+    occurred_start: Optional[StrictStr] = None
+    occurred_end: Optional[StrictStr] = None
+    mentioned_at: Optional[StrictStr] = None
+    document_id: Optional[StrictStr] = None
+    metadata: Optional[Dict[str, StrictStr]] = None
+    chunk_id: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["id", "text", "type", "entities", "context", "occurred_start", "occurred_end", "mentioned_at", "document_id", "metadata", "chunk_id"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RecallResult 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 type (nullable) is None
+        # and model_fields_set contains the field
+        if self.type is None and "type" in self.model_fields_set:
+            _dict['type'] = None
+
+        # set to None if entities (nullable) is None
+        # and model_fields_set contains the field
+        if self.entities is None and "entities" in self.model_fields_set:
+            _dict['entities'] = None
+
+        # set to None if context (nullable) is None
+        # and model_fields_set contains the field
+        if self.context is None and "context" in self.model_fields_set:
+            _dict['context'] = None
+
+        # set to None if occurred_start (nullable) is None
+        # and model_fields_set contains the field
+        if self.occurred_start is None and "occurred_start" in self.model_fields_set:
+            _dict['occurred_start'] = None
+
+        # set to None if occurred_end (nullable) is None
+        # and model_fields_set contains the field
+        if self.occurred_end is None and "occurred_end" in self.model_fields_set:
+            _dict['occurred_end'] = None
+
+        # set to None if mentioned_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.mentioned_at is None and "mentioned_at" in self.model_fields_set:
+            _dict['mentioned_at'] = None
+
+        # set to None if document_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.document_id is None and "document_id" in self.model_fields_set:
+            _dict['document_id'] = None
+
+        # set to None if metadata (nullable) is None
+        # and model_fields_set contains the field
+        if self.metadata is None and "metadata" in self.model_fields_set:
+            _dict['metadata'] = None
+
+        # set to None if chunk_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.chunk_id is None and "chunk_id" in self.model_fields_set:
+            _dict['chunk_id'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RecallResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "text": obj.get("text"),
+            "type": obj.get("type"),
+            "entities": obj.get("entities"),
+            "context": obj.get("context"),
+            "occurred_start": obj.get("occurred_start"),
+            "occurred_end": obj.get("occurred_end"),
+            "mentioned_at": obj.get("mentioned_at"),
+            "document_id": obj.get("document_id"),
+            "metadata": obj.get("metadata"),
+            "chunk_id": obj.get("chunk_id")
+        })
+        return _obj
+
+

hindsight_client_api/models/reflect_fact.py

@@ -0,0 +1,122 @@
+# coding: utf-8
+
+"""
+    Hindsight HTTP API
+
+    HTTP API for Hindsight
+
+    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, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReflectFact(BaseModel):
+    """
+    A fact used in think response.
+    """ # noqa: E501
+    id: Optional[StrictStr] = None
+    text: StrictStr
+    type: Optional[StrictStr] = None
+    context: Optional[StrictStr] = None
+    occurred_start: Optional[StrictStr] = None
+    occurred_end: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["id", "text", "type", "context", "occurred_start", "occurred_end"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ReflectFact 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 id (nullable) is None
+        # and model_fields_set contains the field
+        if self.id is None and "id" in self.model_fields_set:
+            _dict['id'] = None
+
+        # set to None if type (nullable) is None
+        # and model_fields_set contains the field
+        if self.type is None and "type" in self.model_fields_set:
+            _dict['type'] = None
+
+        # set to None if context (nullable) is None
+        # and model_fields_set contains the field
+        if self.context is None and "context" in self.model_fields_set:
+            _dict['context'] = None
+
+        # set to None if occurred_start (nullable) is None
+        # and model_fields_set contains the field
+        if self.occurred_start is None and "occurred_start" in self.model_fields_set:
+            _dict['occurred_start'] = None
+
+        # set to None if occurred_end (nullable) is None
+        # and model_fields_set contains the field
+        if self.occurred_end is None and "occurred_end" in self.model_fields_set:
+            _dict['occurred_end'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ReflectFact from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "id": obj.get("id"),
+            "text": obj.get("text"),
+            "type": obj.get("type"),
+            "context": obj.get("context"),
+            "occurred_start": obj.get("occurred_start"),
+            "occurred_end": obj.get("occurred_end")
+        })
+        return _obj
+
+

hindsight_client_api/models/reflect_include_options.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+"""
+    Hindsight HTTP API
+
+    HTTP API for Hindsight
+
+    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 import Optional, Set
+from typing_extensions import Self
+
+class ReflectIncludeOptions(BaseModel):
+    """
+    Options for including additional data in reflect results.
+    """ # noqa: E501
+    facts: Optional[Dict[str, Any]] = Field(default=None, description="Options for including facts (based_on) in reflect results.")
+    __properties: ClassVar[List[str]] = ["facts"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ReflectIncludeOptions 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 ReflectIncludeOptions from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "facts": obj.get("facts")
+        })
+        return _obj
+
+

hindsight_client_api/models/reflect_request.py

@@ -0,0 +1,118 @@
+# coding: utf-8
+
+"""
+    Hindsight HTTP API
+
+    HTTP API for Hindsight
+
+    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, Optional
+from hindsight_client_api.models.budget import Budget
+from hindsight_client_api.models.metadata_filter import MetadataFilter
+from hindsight_client_api.models.reflect_include_options import ReflectIncludeOptions
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ReflectRequest(BaseModel):
+    """
+    Request model for reflect endpoint.
+    """ # noqa: E501
+    query: StrictStr
+    budget: Optional[Budget] = None
+    context: Optional[StrictStr] = None
+    filters: Optional[List[MetadataFilter]] = None
+    include: Optional[ReflectIncludeOptions] = Field(default=None, description="Options for including additional data (disabled by default)")
+    __properties: ClassVar[List[str]] = ["query", "budget", "context", "filters", "include"]
+
+    model_config = ConfigDict(
+        populate_by_name=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"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ReflectRequest 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 filters (list)
+        _items = []
+        if self.filters:
+            for _item_filters in self.filters:
+                if _item_filters:
+                    _items.append(_item_filters.to_dict())
+            _dict['filters'] = _items
+        # override the default output from pydantic by calling `to_dict()` of include
+        if self.include:
+            _dict['include'] = self.include.to_dict()
+        # set to None if context (nullable) is None
+        # and model_fields_set contains the field
+        if self.context is None and "context" in self.model_fields_set:
+            _dict['context'] = None
+
+        # set to None if filters (nullable) is None
+        # and model_fields_set contains the field
+        if self.filters is None and "filters" in self.model_fields_set:
+            _dict['filters'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ReflectRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "query": obj.get("query"),
+            "budget": obj.get("budget"),
+            "context": obj.get("context"),
+            "filters": [MetadataFilter.from_dict(_item) for _item in obj["filters"]] if obj.get("filters") is not None else None,
+            "include": ReflectIncludeOptions.from_dict(obj["include"]) if obj.get("include") is not None else None
+        })
+        return _obj
+
+