hindsight-client 0.0.13__py3-none-any.whl

hindsight_client/__init__.py

@@ -0,0 +1,26 @@
+"""
+Hindsight Client - Clean, pythonic wrapper for the Hindsight API.
+
+This package provides a high-level interface for common Hindsight operations.
+For advanced use cases, use the auto-generated API client directly.
+
+Example:
+    ```python
+    from hindsight_client import Hindsight
+
+    client = Hindsight(base_url="http://localhost:8888")
+
+    # Store a memory
+    client.put(agent_id="alice", content="Alice loves AI")
+
+    # Search memories
+    results = client.search(agent_id="alice", query="What does Alice like?")
+
+    # Generate contextual answer
+    answer = client.think(agent_id="alice", query="What are my interests?")
+    ```
+"""
+
+from .hindsight_client import Hindsight
+
+__all__ = ["Hindsight"]

hindsight_client/hindsight_client.py

@@ -0,0 +1,432 @@
+"""
+Clean, pythonic wrapper for the Hindsight API client.
+
+This file is MAINTAINED and NOT auto-generated. It provides a high-level,
+easy-to-use interface on top of the auto-generated OpenAPI client.
+"""
+
+import asyncio
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+
+import hindsight_client_api
+from hindsight_client_api.api import default_api
+from hindsight_client_api.models import (
+    recall_request,
+    retain_request,
+    memory_item,
+    reflect_request,
+)
+
+
+def _run_async(coro):
+    """Run an async coroutine synchronously."""
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    return loop.run_until_complete(coro)
+
+
+class Hindsight:
+    """
+    High-level, easy-to-use Hindsight API client.
+
+    Example:
+        ```python
+        from hindsight_client import Hindsight
+
+        client = Hindsight(base_url="http://localhost:8888")
+
+        # Store a memory
+        client.retain(bank_id="alice", content="Alice loves AI")
+
+        # Recall memories
+        results = client.recall(bank_id="alice", query="What does Alice like?")
+
+        # Generate contextual answer
+        answer = client.reflect(bank_id="alice", query="What are my interests?")
+        ```
+    """
+
+    def __init__(self, base_url: str, timeout: float = 30.0):
+        """
+        Initialize the Hindsight client.
+
+        Args:
+            base_url: The base URL of the Hindsight API server
+            timeout: Request timeout in seconds (default: 30.0)
+        """
+        config = hindsight_client_api.Configuration(host=base_url)
+        self._api_client = hindsight_client_api.ApiClient(config)
+        self._api = default_api.DefaultApi(self._api_client)
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()
+
+    def close(self):
+        """Close the API client."""
+        if self._api_client:
+            _run_async(self._api_client.close())
+
+    # Simplified methods for main operations
+
+    def retain(
+        self,
+        bank_id: str,
+        content: str,
+        timestamp: Optional[datetime] = None,
+        context: Optional[str] = None,
+        document_id: Optional[str] = None,
+        metadata: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Store a single memory (simplified interface).
+
+        Args:
+            bank_id: The memory bank ID
+            content: Memory content
+            timestamp: Optional event timestamp
+            context: Optional context description
+            document_id: Optional document ID for grouping
+            metadata: Optional user-defined metadata
+
+        Returns:
+            Response with success status
+        """
+        return self.retain_batch(
+            bank_id=bank_id,
+            items=[{"content": content, "timestamp": timestamp, "context": context, "metadata": metadata}],
+            document_id=document_id,
+        )
+
+    def retain_batch(
+        self,
+        bank_id: str,
+        items: List[Dict[str, Any]],
+        document_id: Optional[str] = None,
+        async_: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Store multiple memories in batch.
+
+        Args:
+            bank_id: The memory bank ID
+            items: List of memory items with 'content' and optional 'timestamp', 'context', 'metadata'
+            document_id: Optional document ID for grouping memories
+            async_: If True, process asynchronously in background (default: False)
+
+        Returns:
+            Response with success status and item count
+        """
+        memory_items = [
+            memory_item.MemoryItem(
+                content=item["content"],
+                timestamp=item.get("timestamp"),
+                context=item.get("context"),
+                metadata=item.get("metadata"),
+            )
+            for item in items
+        ]
+
+        request_obj = retain_request.RetainRequest(
+            items=memory_items,
+            document_id=document_id,
+            async_=async_,
+        )
+
+        response = _run_async(self._api.retain_memories(bank_id, request_obj))
+        return response.to_dict() if hasattr(response, 'to_dict') else response
+
+    def recall(
+        self,
+        bank_id: str,
+        query: str,
+        types: Optional[List[str]] = None,
+        max_tokens: int = 4096,
+        budget: str = "mid",
+    ) -> List[Dict[str, Any]]:
+        """
+        Recall memories using semantic similarity.
+
+        Args:
+            bank_id: The memory bank ID
+            query: Search query
+            types: Optional list of fact types to filter (world, agent, opinion, observation)
+            max_tokens: Maximum tokens in results (default: 4096)
+            budget: Budget level for recall - "low", "mid", or "high" (default: "mid")
+
+        Returns:
+            List of recall results
+        """
+        request_obj = recall_request.RecallRequest(
+            query=query,
+            types=types,
+            budget=budget,
+            max_tokens=max_tokens,
+            trace=False,
+        )
+
+        response = _run_async(self._api.recall_memories(bank_id, request_obj))
+
+        if hasattr(response, 'results'):
+            return [r.to_dict() if hasattr(r, 'to_dict') else r for r in response.results]
+        return []
+
+    def reflect(
+        self,
+        bank_id: str,
+        query: str,
+        budget: str = "low",
+        context: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Generate a contextual answer based on bank identity and memories.
+
+        Args:
+            bank_id: The memory bank ID
+            query: The question or prompt
+            budget: Budget level for reflection - "low", "mid", or "high" (default: "low")
+            context: Optional additional context
+
+        Returns:
+            Response with answer text and optionally facts used
+        """
+        request_obj = reflect_request.ReflectRequest(
+            query=query,
+            budget=budget,
+            context=context,
+        )
+
+        response = _run_async(self._api.reflect(bank_id, request_obj))
+        return response.to_dict() if hasattr(response, 'to_dict') else response
+
+    # Full-featured methods (expose more options)
+
+    def recall_memories(
+        self,
+        bank_id: str,
+        query: str,
+        types: Optional[List[str]] = None,
+        budget: str = "mid",
+        max_tokens: int = 4096,
+        trace: bool = False,
+        query_timestamp: Optional[str] = None,
+        include_entities: bool = True,
+        max_entity_tokens: int = 500,
+    ) -> Dict[str, Any]:
+        """
+        Recall memories with all options (full-featured).
+
+        Args:
+            bank_id: The memory bank ID
+            query: Search query
+            types: Optional list of fact types to filter (world, agent, opinion, observation)
+            budget: Budget level - "low", "mid", or "high"
+            max_tokens: Maximum tokens in results
+            trace: Enable trace output
+            query_timestamp: Optional ISO format date string (e.g., '2023-05-30T23:40:00')
+            include_entities: Include entity observations in results (default: True)
+            max_entity_tokens: Maximum tokens for entity observations (default: 500)
+
+        Returns:
+            Full recall response with results, optional entities, and optional trace
+        """
+        from hindsight_client_api.models import include_options, entity_include_options
+
+        include_opts = include_options.IncludeOptions(
+            entities=entity_include_options.EntityIncludeOptions(max_tokens=max_entity_tokens) if include_entities else None
+        )
+
+        request_obj = recall_request.RecallRequest(
+            query=query,
+            types=types,
+            budget=budget,
+            max_tokens=max_tokens,
+            trace=trace,
+            query_timestamp=query_timestamp,
+            include=include_opts,
+        )
+
+        response = _run_async(self._api.recall_memories(bank_id, request_obj))
+        return response.to_dict() if hasattr(response, 'to_dict') else response
+
+    def list_memories(
+        self,
+        bank_id: str,
+        type: Optional[str] = None,
+        search_query: Optional[str] = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> Dict[str, Any]:
+        """List memory units with pagination."""
+        response = _run_async(self._api.list_memories(
+            bank_id=bank_id,
+            type=type,
+            q=search_query,
+            limit=limit,
+            offset=offset,
+        ))
+        return response.to_dict() if hasattr(response, 'to_dict') else response
+
+    def create_bank(
+        self,
+        bank_id: str,
+        name: Optional[str] = None,
+        background: Optional[str] = None,
+        personality: Optional[Dict[str, float]] = None,
+    ) -> Dict[str, Any]:
+        """Create or update a memory bank."""
+        from hindsight_client_api.models import create_bank_request, personality_traits
+
+        personality_obj = None
+        if personality:
+            personality_obj = personality_traits.PersonalityTraits(**personality)
+
+        request_obj = create_bank_request.CreateBankRequest(
+            name=name,
+            background=background,
+            personality=personality_obj,
+        )
+
+        response = _run_async(self._api.create_or_update_bank(bank_id, request_obj))
+        return response.to_dict() if hasattr(response, 'to_dict') else response
+
+    # Async methods (native async, no _run_async wrapper)
+
+    async def aretain_batch(
+        self,
+        bank_id: str,
+        items: List[Dict[str, Any]],
+        document_id: Optional[str] = None,
+        async_: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Store multiple memories in batch (async).
+
+        Args:
+            bank_id: The memory bank ID
+            items: List of memory items with 'content' and optional 'timestamp', 'context', 'metadata'
+            document_id: Optional document ID for grouping memories
+            async_: If True, process asynchronously in background (default: False)
+
+        Returns:
+            Response with success status and item count
+        """
+        memory_items = [
+            memory_item.MemoryItem(
+                content=item["content"],
+                timestamp=item.get("timestamp"),
+                context=item.get("context"),
+                metadata=item.get("metadata"),
+            )
+            for item in items
+        ]
+
+        request_obj = retain_request.RetainRequest(
+            items=memory_items,
+            document_id=document_id,
+            async_=async_,
+        )
+
+        response = await self._api.retain_memories(bank_id, request_obj)
+        return response.to_dict() if hasattr(response, 'to_dict') else response
+
+    async def aretain(
+        self,
+        bank_id: str,
+        content: str,
+        timestamp: Optional[datetime] = None,
+        context: Optional[str] = None,
+        document_id: Optional[str] = None,
+        metadata: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Store a single memory (async).
+
+        Args:
+            bank_id: The memory bank ID
+            content: Memory content
+            timestamp: Optional event timestamp
+            context: Optional context description
+            document_id: Optional document ID for grouping
+            metadata: Optional user-defined metadata
+
+        Returns:
+            Response with success status
+        """
+        return await self.aretain_batch(
+            bank_id=bank_id,
+            items=[{"content": content, "timestamp": timestamp, "context": context, "metadata": metadata}],
+            document_id=document_id,
+        )
+
+    async def arecall(
+        self,
+        bank_id: str,
+        query: str,
+        types: Optional[List[str]] = None,
+        max_tokens: int = 4096,
+        budget: str = "mid",
+    ) -> List[Dict[str, Any]]:
+        """
+        Recall memories using semantic similarity (async).
+
+        Args:
+            bank_id: The memory bank ID
+            query: Search query
+            types: Optional list of fact types to filter (world, agent, opinion, observation)
+            max_tokens: Maximum tokens in results (default: 4096)
+            budget: Budget level for recall - "low", "mid", or "high" (default: "mid")
+
+        Returns:
+            List of recall results
+        """
+        request_obj = recall_request.RecallRequest(
+            query=query,
+            types=types,
+            budget=budget,
+            max_tokens=max_tokens,
+            trace=False,
+        )
+
+        response = await self._api.recall_memories(bank_id, request_obj)
+
+        if hasattr(response, 'results'):
+            return [r.to_dict() if hasattr(r, 'to_dict') else r for r in response.results]
+        return []
+
+    async def areflect(
+        self,
+        bank_id: str,
+        query: str,
+        budget: str = "low",
+        context: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Generate a contextual answer based on bank identity and memories (async).
+
+        Args:
+            bank_id: The memory bank ID
+            query: The question or prompt
+            budget: Budget level for reflection - "low", "mid", or "high" (default: "low")
+            context: Optional additional context
+
+        Returns:
+            Response with answer text and optionally facts used
+        """
+        request_obj = reflect_request.ReflectRequest(
+            query=query,
+            budget=budget,
+            context=context,
+        )
+
+        response = await self._api.reflect(bank_id, request_obj)
+        return response.to_dict() if hasattr(response, 'to_dict') else response

hindsight_client-0.0.13.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: hindsight-client
+Version: 0.0.13
+Summary: Python client for Hindsight - Semantic memory system with personality-driven thinking
+Author: Hindsight Team
+Requires-Python: >=3.10
+Requires-Dist: aiohttp-retry>=2.8.3
+Requires-Dist: aiohttp>=3.8.4
+Requires-Dist: pydantic>=2
+Requires-Dist: python-dateutil>=2.8.2
+Requires-Dist: typing-extensions>=4.7.1
+Requires-Dist: urllib3<3.0.0,>=2.1.0
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'test'
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Hindsight Python Client
+
+Python client library for the Hindsight API.
+
+## Installation
+
+```bash
+pip install hindsight-client
+```
+
+## Usage
+
+```python
+from hindsight_client import Hindsight
+
+client = Hindsight(base_url="http://localhost:8888")
+
+# Retain information
+client.retain(
+    bank_id="my-bank",
+    content="Alice works at Google in Mountain View."
+)
+
+# Recall memories
+results = client.recall(
+    bank_id="my-bank",
+    query="Where does Alice work?"
+)
+
+# Reflect and get an opinion
+response = client.reflect(
+    bank_id="my-bank",
+    query="What do you think about Alice's career?"
+)
+```
+
+## Documentation
+
+For full documentation, visit [hindsight.dev](https://hindsight.dev).

hindsight_client-0.0.13.dist-info/RECORD

@@ -0,0 +1,134 @@
+hindsight_client/__init__.py,sha256=yDyA5gfFW0MpAl5GIDbfw7Sm1KtocMa-ltStjL6KwnM,711
+hindsight_client/hindsight_client.py,sha256=E_xFdpHmIFVrkS1HkVb-hfYn69_Hh7SzLnjMIDFsm6U,13865
+hindsight_client_api/__init__.py,sha256=XT5Rud7nuVtKKT12yT-fPNjcrKccjDArg2VcDgjq_3I,6052
+hindsight_client_api/api_client.py,sha256=gO_s4kVFGPJMawvNcdoqbpqptHIIKELylVni48b7rqU,27860
+hindsight_client_api/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
+hindsight_client_api/configuration.py,sha256=OV4VlRbFSSxdfxTuo81DlL_QmZbT_-FHn39h-XW7VOQ,17787
+hindsight_client_api/exceptions.py,sha256=d0pwToyNcSfRzoBrHUsBrmcm9hssBErq0zGFO0cAboE,6470
+hindsight_client_api/rest.py,sha256=MRNjKt09uidHHL0RF76t5XlwIXAinJV_uvdkJrDoo1I,7225
+hindsight_client_api/api/__init__.py,sha256=aWzhDj7Q3Q5obQwQA-fOtPO2looklumbsAbnLGl_Fhw,174
+hindsight_client_api/api/default_api.py,sha256=WEGywEiYrX8XY8Uku4mkyT7wpwV0IS7q20J4g4aLdao,235937
+hindsight_client_api/api/monitoring_api.py,sha256=t7UGHKOXLCWET6kgy5CmjDQ54SSVDWwekh0j7XTxw20,10408
+hindsight_client_api/docs/AddBackgroundRequest.md,sha256=co9zT309qLV58Xob8V0vejGlAEEuLTUhbTy-I_CgR1I,1223
+hindsight_client_api/docs/BackgroundResponse.md,sha256=3R8rS922JZv3KHbf910lt_IygRK_Zs-H2DqBoAbdH00,1061
+hindsight_client_api/docs/BankListItem.md,sha256=PQp3pZ6EV4Ah7u43iKGOUWBa7xFvP50dZ8098zWoX38,1114
+hindsight_client_api/docs/BankListResponse.md,sha256=20McKN_iVmyOFzQBGOGo-a0D7P2YJTeh31GJna1P6J8,989
+hindsight_client_api/docs/BankProfileResponse.md,sha256=AUQpiUs65lklpw7v_HTXmwMAcAExjCdgRgD3p8wr_HM,1117
+hindsight_client_api/docs/Budget.md,sha256=UMCVLms95l0XATPyK4VcTQoeGQjRv6FsnaKZ547s0Ow,309
+hindsight_client_api/docs/ChunkData.md,sha256=8HaU0DkJnIcVayGQc52noa-QxoM_lckzfX0p3B0cVsg,1021
+hindsight_client_api/docs/ChunkIncludeOptions.md,sha256=zPqCLDkW7flyLjJdhrBnh97zm8Y7WTs-kkaYI1xK9G0,1088
+hindsight_client_api/docs/ChunkResponse.md,sha256=6qZwJfZATMT2dD8ML8IDJ7eSwF-8bmuKz2pLGU1UYPE,1068
+hindsight_client_api/docs/CreateBankRequest.md,sha256=91V_NCrVUib72AW45rQDam4FCiJ5td_vuSPJVqbSxS0,1107
+hindsight_client_api/docs/DefaultApi.md,sha256=bEYpqUdN-c1Z-SjW0K5nTZw_ZZXDgvZ889wKr8fqA2A,48669
+hindsight_client_api/docs/DeleteResponse.md,sha256=k3NHvJoSjemZDGZ_huMXk0gtNKYkDSyGsQ7PCB5aybI,926
+hindsight_client_api/docs/DocumentResponse.md,sha256=ruwb2llltuJLZ3KoVJ-zwF3C7ELjpjaUNet9OK-4JKQ,1145
+hindsight_client_api/docs/EntityDetailResponse.md,sha256=Ea6SGkeMCZWzhOGyzJ5nP7PU7a6SBit6GL8gWnNyOvA,1308
+hindsight_client_api/docs/EntityIncludeOptions.md,sha256=ldI3RHhT8ub11bc1hmwqCEy4XGzJrFq08NGfEXy7p_Y,1100
+hindsight_client_api/docs/EntityListItem.md,sha256=BpYo9ftZyCHUlB6xPURvCvGu_7YSore0xt8Y_b-4gHA,1125
+hindsight_client_api/docs/EntityListResponse.md,sha256=uwzq605X0L8iHDVR12pIG0t-iVPCgUz5NR39lyWYgqE,1022
+hindsight_client_api/docs/EntityObservationResponse.md,sha256=6-7UxvIKFqGyQaoyHOdadHzXnAigOb2zGHXmpvr6rf0,1109
+hindsight_client_api/docs/EntityStateResponse.md,sha256=08ntXHc69PVXiOGcrg3HwqeYo9wHG5ivfcAvJI-C6eQ,1123
+hindsight_client_api/docs/GraphDataResponse.md,sha256=UIsZmMFNXwKNujVeha8TFPiq4HxZqHOWDXNXbm1yNm8,1119
+hindsight_client_api/docs/HTTPValidationError.md,sha256=IZC9oMGPXsIFy7yeKKgRpZHQXzz0wyIp2ZChHA9MaXI,1008
+hindsight_client_api/docs/IncludeOptions.md,sha256=GZ4xlW2amRYgWq_dL7sdmnrmUdWtdY9FnHqKhotcRoI,1080
+hindsight_client_api/docs/ListDocumentsResponse.md,sha256=knIyqPUGLe1Pg0dLnjrnHgO1RqB7RisKEZWSyiX4oiI,1125
+hindsight_client_api/docs/ListMemoryUnitsResponse.md,sha256=UBFQ1uJd9AAcRHWtgr7hjx86ka_EmPKr5LwH15UO2Mc,1160
+hindsight_client_api/docs/MemoryItem.md,sha256=UaHZE9BQO9BJgsGJL8QfAeuogtCZmFoH4XZshoyLmcI,1045
+hindsight_client_api/docs/MetadataFilter.md,sha256=K7WQ-K1GM4I9nIuCcWCkMVyWqkEKb_xClM3N8QmZp18,1170
+hindsight_client_api/docs/MonitoringApi.md,sha256=CTnVtwDHWBRqMRboIap7uJokLpSmdLWun8yxlK_lQuM,1976
+hindsight_client_api/docs/PersonalityTraits.md,sha256=p6kx-lTP_tWj-8UnwZDySdFj1DHIWCZut1ULkuwMGbA,1309
+hindsight_client_api/docs/RecallRequest.md,sha256=DX3ADDMnKaQBhYasXfEHxQhJwjuKVO8YH5hcyaAZYts,1386
+hindsight_client_api/docs/RecallResponse.md,sha256=VbABZlZwMTaSuqaqAAOOAjkuqaDB4azaQAFP5noJkVc,1173
+hindsight_client_api/docs/RecallResult.md,sha256=1QTIqPN86Gq--tw-LwFVBmO5QD4dj8DbzJqe0ywUrew,1297
+hindsight_client_api/docs/ReflectFact.md,sha256=f9wmQde692is1dF6sw6S5_zIDI9Z_AHSbCvD7ALluLY,1075
+hindsight_client_api/docs/ReflectIncludeOptions.md,sha256=tH-pQeSv0QH9hoLmQhsg0PO5R3jVolDK6JFUG5CHi50,1112
+hindsight_client_api/docs/ReflectRequest.md,sha256=066vUaiiXUf9yau5y7jJLTMDqVcSjOhyckbdj-kdc3A,1235
+hindsight_client_api/docs/ReflectResponse.md,sha256=ziZtjLkXfX7RieaBtL5XC1JxgyG5_1rda-pZHHrQAaA,1019
+hindsight_client_api/docs/RetainRequest.md,sha256=u-IhxRJo2iFWtskDsRpBJJjOdm7mfLGE6j1W6iNTcKY,1090
+hindsight_client_api/docs/RetainResponse.md,sha256=2a3Wz7ilrnQ_BFf6YTqWDmA94gohs8kU9sCR3mJYrj8,1065
+hindsight_client_api/docs/UpdatePersonalityRequest.md,sha256=j7HBHSFWFfR7B8lJqfEY37lorG075uv7R_ShdoeZmRo,1112
+hindsight_client_api/docs/ValidationError.md,sha256=moV1dyA1z8n2DSD18ri7x7GDJujHc6--fbwGr4u8cl4,1001
+hindsight_client_api/docs/ValidationErrorLocInner.md,sha256=WP7Zm2LNt2HZb6XHo0cLvLCrht-EGFKp0i4zD3jPMto,988
+hindsight_client_api/models/__init__.py,sha256=px7xyeosOlkWejYftFpGmWrTKtFi34K95K6GdmyLqLc,3187
+hindsight_client_api/models/add_background_request.py,sha256=UiRFfyOEQ8MYqeleKE2tX5b1ZQNxUQIV8QqGRDx1d9Y,2876
+hindsight_client_api/models/background_response.py,sha256=LrwGkXzBrCWLRQPB4VabaTa5Ugb9fUXPFT6RzKmJwJE,3144
+hindsight_client_api/models/bank_list_item.py,sha256=63XSHeoNRzmoK_7anUssKyWyqso0MbuI8-fYaaxulR8,3681
+hindsight_client_api/models/bank_list_response.py,sha256=8ywzWZEJCj3_02-5twORc7sGWIC6T114G7aDDzOqOh4,2896
+hindsight_client_api/models/bank_profile_response.py,sha256=6cxnw7Dviy5HgvwQsjSZJnuxXv45VHL2BWyO5N9htc0,3030
+hindsight_client_api/models/budget.py,sha256=MxiFUUh-b8sV6rTuVDeAIJduou1FHU8zi_hD5V-JWYg,702
+hindsight_client_api/models/chunk_data.py,sha256=ARH2uO5RWbB6GNgVtzi3ADo7ijKTlWmc5uGuNhkS53k,2828
+hindsight_client_api/models/chunk_include_options.py,sha256=uqlWWYPajjvDsfCouY8Ysw8OYQ3GtR9h7QLmn-8K534,2634
+hindsight_client_api/models/chunk_response.py,sha256=nrwHLEaFTfcYaRhdf2eGa7YOV075fwG09C1sG7IwVUY,2888
+hindsight_client_api/models/create_bank_request.py,sha256=2ymRgmfVtxAzCw41kVlGZhQBgthXaNbE9dNeZQr3bdw,3668
+hindsight_client_api/models/delete_response.py,sha256=ruXyEg7cavfXXmVrWmh_k8Kabpo-ef1iTY_aiOehS5k,2436
+hindsight_client_api/models/document_response.py,sha256=HOJ0TTKF7Bkdii-UyfUOzMNcJhrzrgShSxDq6z2vFjE,3256
+hindsight_client_api/models/entity_detail_response.py,sha256=rHv59Hvk0U5GFw-n4FIT_GMypPNGAuOzzNXu8b7zvCU,4312
+hindsight_client_api/models/entity_include_options.py,sha256=qRo4gnHEKl8GugqNl24ugEV0nSusdEcZycxKU2YgHIM,2635
+hindsight_client_api/models/entity_list_item.py,sha256=RVuWRo5YEE9CPAGsJjQpIPGlCaGYdZMcsTWofn7EHRs,3602
+hindsight_client_api/models/entity_list_response.py,sha256=xi2oBFliGHdr6Oabh3ubZBUYwpsVt9HYPrVpTbr5VSk,2913
+hindsight_client_api/models/entity_observation_response.py,sha256=600r__u4bPWJkEtZ2IF0trnQLdrZp_ybJNUf8BcJiq0,2804
+hindsight_client_api/models/entity_state_response.py,sha256=1b3ZmUT8GWs3u0HTl3Un56kiPXN8tQAgD9EO_C3K2EM,3239
+hindsight_client_api/models/graph_data_response.py,sha256=uzWzj-60AQRObcYplaDeNqbMCJ6tAuGhEBCTpqB0L5g,2721
+hindsight_client_api/models/http_validation_error.py,sha256=GLVEdsmTx9xa8jC11qt5N8-Ich7s8nkXpQp9kIL6lcg,2937
+hindsight_client_api/models/include_options.py,sha256=jqNB_VdponAnlrY6vhRv54UOdBkH3UayJRzOMnD-dpI,3645
+hindsight_client_api/models/list_documents_response.py,sha256=RACBMWojY9yVfQlTt600xG1AFOO20S3SKyh_R24kpzw,2675
+hindsight_client_api/models/list_memory_units_response.py,sha256=_B7-Aw-0VCny98lP3zt9VQomR6zEvSQ84q1CQIXb6Os,2684
+hindsight_client_api/models/memory_item.py,sha256=97_WLBTKBxtE37r39LO1Rv4AuS8SHHmvOqFydD0cVaM,3741
+hindsight_client_api/models/metadata_filter.py,sha256=DsQdItQamsavISgHL4QO8DCwPFCmeoCbvtVtQLU-OWk,3101
+hindsight_client_api/models/personality_traits.py,sha256=Cr1AAtTcWVwackp-wSxsUwYIInfQujbPc2VVyuuumuA,3892
+hindsight_client_api/models/recall_request.py,sha256=ILhJEgnJG-Te4M8lrotE7dqpvkujTWPI2Y2qjGaMpS0,4856
+hindsight_client_api/models/recall_response.py,sha256=PlLOE1_ixkUcDSjKnNng2-8uoL3sGeFgHHQJ8CI-CNE,5103
+hindsight_client_api/models/recall_result.py,sha256=CmIN7BF6zBBwl8hpmce4rHVMB4GS0PwbzUMcQZn2QN0,5402
+hindsight_client_api/models/reflect_fact.py,sha256=PVXV3yTMrVIawv2HMLC-fBOEo4QxQGe0JAgiOsaigaU,3973
+hindsight_client_api/models/reflect_include_options.py,sha256=G1l38KRDvXhYLRTb-Yfwjzh6ETXdU0qX5iLwMSd1mIE,2584
+hindsight_client_api/models/reflect_request.py,sha256=fJ-6xSckV-XTMvM7g-oJVDdj-0InJv8pGIZTvgq6m54,4210
+hindsight_client_api/models/reflect_response.py,sha256=4pS5fgZa34wsdb4HmuSYOS8gu1-gS9akuRU-e77pxAM,3024
+hindsight_client_api/models/retain_request.py,sha256=t6uB_mIrjMsHm5zdwrhPzdqVjoVyqqNijcMRL0_a9iE,3178
+hindsight_client_api/models/retain_response.py,sha256=LmtP9CsPvsfLIYhmz0xsWFHI4AOg1C9CT49D-_Wfing,2796
+hindsight_client_api/models/update_personality_request.py,sha256=y_JDP8wrr93BqgAlzrzNlhVhPKiSETNS-sI9AkrbiYQ,2817
+hindsight_client_api/models/validation_error.py,sha256=iRhOO1MxLQvZiiM5xyMbJSrhJUspG-Bn2HZ-nMCxUhg,3029
+hindsight_client_api/models/validation_error_loc_inner.py,sha256=YmggpQXbrX6V2q-s29sTsI59p72DXi2MoUZPfAVpMZ8,4812
+hindsight_client_api/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hindsight_client_api/test/test_add_background_request.py,sha256=DS7JQE3xWHmpYvtR09pVQSAO6ci6lacaHaDoMRmQfCw,1463
+hindsight_client_api/test/test_background_response.py,sha256=C1sPSFj9p9PuJIsPU7BSsAxguK8UdCDTfcwnkW79PLs,1543
+hindsight_client_api/test/test_bank_list_item.py,sha256=_htF0NYhrUIgSfxks6YvgVyp18ymolkmZ2UNlEk1yFw,1794
+hindsight_client_api/test/test_bank_list_response.py,sha256=nJ_OfZ2km2LZUc8N78O_AJBSTtg_glFH4vT2begA3X4,2270
+hindsight_client_api/test/test_bank_profile_response.py,sha256=v8EjsEQKfKKSFwGgerydVjzRgJDIuQhluTHVE1fHBnQ,1812
+hindsight_client_api/test/test_budget.py,sha256=QZBlqIwkAqbVs-Fe0DrG460XIuQcN4LWEG6mziRDrtY,587
+hindsight_client_api/test/test_chunk_data.py,sha256=KPi51APTLgtmR2_f5FSH3KQ_fHeC_zC1tEZvattugPE,1433
+hindsight_client_api/test/test_chunk_include_options.py,sha256=kF2kUuw_QhG9D7Rg1L_yJvUvz6QUcZA_yFzR7PwP8t0,1381
+hindsight_client_api/test/test_chunk_response.py,sha256=OOgrcSEef7G1qx17JQ9ApGLreeObocCMdhmirwgg7Uw,1665
+hindsight_client_api/test/test_create_bank_request.py,sha256=ORDjPpEbX1yDaBkIYTg921eAZOStjwSEaWGsCiqkiQA,1526
+hindsight_client_api/test/test_default_api.py,sha256=ymKx13UyTxRlDrKy20UB6DGCRnO97edcXpQEBIxERX0,3759
+hindsight_client_api/test/test_delete_response.py,sha256=Wb7j_7QvyeTdPMbybxHUdYnpr0Cqk-Rqw2nIdLNEkJY,1351
+hindsight_client_api/test/test_document_response.py,sha256=PIGFqjTUslp9I5pKW9Ly0w325oax6cjDNzUf2hM28dk,1775
+hindsight_client_api/test/test_entity_detail_response.py,sha256=VpPyYpGYxtnTKspDbIeLtM4lC9j5hMW97pPUjKaZPjs,2186
+hindsight_client_api/test/test_entity_include_options.py,sha256=vEI63Q0Ejh7IRgH1TxXWVal08WYk1KwBo0n3tdpxBxY,1393
+hindsight_client_api/test/test_entity_list_item.py,sha256=ZL8sK97yWZg_MXlZYDiUsC-IEKZLwQI__8Pwq6nMY_s,1634
+hindsight_client_api/test/test_entity_list_response.py,sha256=nFA6ryE4Eg1m7EGw60_-h3G5ro6t06Qa3yMjHXwERb0,1766
+hindsight_client_api/test/test_entity_observation_response.py,sha256=EEpD8Zf3XcXH0zdQs2Bh81LfGBVPAq9Z5z8C7lfLqv4,1509
+hindsight_client_api/test/test_entity_state_response.py,sha256=TTnOCPQMgdoTCyQb-12ZBIDLQiYXa-7HQZ3P-NVy9Lk,1966
+hindsight_client_api/test/test_graph_data_response.py,sha256=-c8u7AaFG-FjDaktnkMHFsmBYQmlU_ijIBQPFIkoHyI,2206
+hindsight_client_api/test/test_http_validation_error.py,sha256=hzSbwTv55PQ__XRxXX7PXu9nxKECR9LtJvrrN8Mn1aU,1649
+hindsight_client_api/test/test_include_options.py,sha256=nibccUakKvfSa_dLV7trlbnT5ctGA7ytj54KztfVVUQ,1563
+hindsight_client_api/test/test_list_documents_response.py,sha256=EwpI71z-8IdxmWdXIhfejfrg_9_ElaYQDXL0HXWa-js,1810
+hindsight_client_api/test/test_list_memory_units_response.py,sha256=TsNnYc_9aNcczAsSjMd4kFW2Zs7DLe4teWZh5BfLWTY,1835
+hindsight_client_api/test/test_memory_item.py,sha256=H82GmKPm-mmRk_PRY6lqv0QomZ5BV_-TbbgUsG_tp-E,1552
+hindsight_client_api/test/test_metadata_filter.py,sha256=y9zZ1CfVp8Xnfb3bmH-ySvCPgVmc6SIquuyG9TagZbw,1403
+hindsight_client_api/test/test_monitoring_api.py,sha256=E_n9Zea2dBF47iM2493w_daZvx6ErII7CdGn-cad9iY,820
+hindsight_client_api/test/test_personality_traits.py,sha256=sgubpsa-cK9Tt7No-A4aPrDn5OLEXef51FMYwEG85nM,1759
+hindsight_client_api/test/test_recall_request.py,sha256=dTxiICITLrert8NZoUkql3cD286_TjVV0RrhicJhm_E,2033
+hindsight_client_api/test/test_recall_response.py,sha256=K7IJXHOM8u21TOvsdn4jfTcbU7v7BvbNW17iOMQM2vw,3014
+hindsight_client_api/test/test_recall_result.py,sha256=ZDJaN1iQOs9q_mfBpJBTvpAQc-OUTMsCMymPsWV6W2c,1754
+hindsight_client_api/test/test_reflect_fact.py,sha256=dW_Y-0QITw80-XCYjzcmMcHIBNw7C6LVEKGQ97k3bIE,1459
+hindsight_client_api/test/test_reflect_include_options.py,sha256=C1rHezODwNC1u1iLXWnF2YLKInKoYpCEuiREQevq7HM,1469
+hindsight_client_api/test/test_reflect_request.py,sha256=s_bkT4efjMlgUmI_kKmGhjdIQ8hh4TqlZUnW3Q7rIqQ,1725
+hindsight_client_api/test/test_reflect_response.py,sha256=m6ivE97QzgRZjxvlGDlfKOIcIcqfhyauLcu7CTQZvtE,1613
+hindsight_client_api/test/test_retain_request.py,sha256=4_-f9yQR37373t3p-2_FXq9KRWQa3kr0Gw3Z4w56GcQ,1839
+hindsight_client_api/test/test_retain_response.py,sha256=L_83q5aYZAb9mZhHwF7WAe4dkmrOCFe8mSCpCjS5ZLE,1547
+hindsight_client_api/test/test_update_personality_request.py,sha256=g3OO7fy2w4KuxF0phkXIXqJA2o-6fLY8k6lLcw07XSg,1692
+hindsight_client_api/test/test_validation_error.py,sha256=FiG2lcCSznxrbqRk2rcKv1ctpin0gGM5YGReZWMRnkw,1549
+hindsight_client_api/test/test_validation_error_loc_inner.py,sha256=Cy-VdSn1aBCRzpiI-2OSCrK376C5eHDywvbF16KNhMQ,1398
+hindsight_client-0.0.13.dist-info/METADATA,sha256=i_3DdseYFPWPLkzVkujEkKp4anyQGIjXjwB2Qyv4fL0,1266
+hindsight_client-0.0.13.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hindsight_client-0.0.13.dist-info/RECORD,,

hindsight_client-0.0.13.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any