mgraph-ai-service-cache-client 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

mgraph_ai_service_cache_client/client_contract/data/Service__Fast_API__Client__Data__Retrieve.py

@@ -0,0 +1,87 @@
+from typing                          import Any, Dict
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+class Service__Fast_API__Client__Data__Retrieve(Type_Safe):
+    _client: Any                                                                    # Reference to main client
+
+    @property
+    def requests(self):                                                             # Access the unified request handler
+        return self._client.requests()
+
+    def data__json__with__id(self, cache_id: str, namespace: str, data_file_id: str) -> Dict:                              # Auto-generated from endpoint get__data__json__with__id
+                                                                                    # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/json/{data_file_id}"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def data__json__with__id_and_key(self, cache_id: str, namespace: str, data_key: str, data_file_id: str) -> Dict:                              # Auto-generated from endpoint get__data__json__with__id_and_key
+                                                                                    # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/json/{data_key}/{data_file_id}"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def data__string__with__id(self, cache_id: str, namespace: str, data_file_id: str) -> Dict:                              # Auto-generated from endpoint get__data__string__with__id
+                                                                                    # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/string/{data_file_id}"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def data__string__with__id_and_key(self, cache_id: str, namespace: str, data_key: str, data_file_id: str) -> Dict:                              # Auto-generated from endpoint get__data__string__with__id_and_key
+                                                                                    # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/string/{data_key}/{data_file_id}"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def data__binary__with__id(self, cache_id: str, namespace: str, data_file_id: str) -> Dict:                              # Auto-generated from endpoint get__data__binary__with__id
+                                                                                    # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/binary/{data_file_id}"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+        return result.content
+        #return result.json if result.json else result.text                         # Return response data
+
+    def data__binary__with__id_and_key(self, cache_id: str, namespace: str, data_key: str, data_file_id: str) -> Dict:                              # Auto-generated from endpoint get__data__binary__with__id_and_key
+                                                                                    # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/binary/{data_key}/{data_file_id}"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+        return result.content
+        return result.json if result.json else result.text                          # Return response data

mgraph_ai_service_cache_client/client_contract/data_store/Service__Fast_API__Client__Data__Store.py

@@ -0,0 +1,148 @@
+from typing  import Any, Dict
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+from osbot_utils.type_safe.primitives.domains.files.safe_str.Safe_Str__File__Path   import Safe_Str__File__Path
+from osbot_utils.type_safe.primitives.domains.identifiers.safe_str.Safe_Str__Id     import Safe_Str__Id
+
+
+class Service__Fast_API__Client__Data__Store(Type_Safe):
+    _client: Any                                                                    # Reference to main client
+
+    @property
+    def requests(self):                                                             # Access the unified request handler
+        return self._client.requests()
+
+    def data__store_binary(self, cache_id: str, namespace: str, body:bytes) -> Dict:                              # Auto-generated from endpoint post__data__store_binary
+                                                                                    # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/store/binary"
+        #body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "POST",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def data__store_binary__with__id(self, cache_id: str, namespace: str, data_file_id: str, body:bytes) -> Dict:                              # Auto-generated from endpoint post__data__store_binary__with__id
+                                                                                    # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/store/binary/{data_file_id}"
+        #body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "POST",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def data__store_binary__with__id_and_key(self, cache_id: str, namespace: str, data_key: str, data_file_id: str, body:bytes) -> Dict:                              # Auto-generated from endpoint post__data__store_binary__with__id_and_key
+                                                                                    # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/store/binary/{data_key}/{data_file_id}"
+        #body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "POST",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def data__store_json(self, cache_id: str, namespace: str, body:dict) -> Dict:                              # Auto-generated from endpoint post__data__store_json
+                                                                                    # Build path
+        #path = f"/{{namespace}}/cache/{{cache_id}}/data/store/json"
+        path = f"/{namespace}/cache/{cache_id}/data/store/json"
+        #body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "POST",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def data__store_json__with__id(self, cache_id: str, namespace: str, data_file_id: str, body:dict) -> Dict:                              # Auto-generated from endpoint post__data__store_json__with__id
+                                                                                    # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/store/json/{data_file_id}"
+        #body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "POST",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def data__store_json__with__id_and_key(self, cache_id: str,
+                                           namespace: str, data_key: str,
+                                           data_file_id: str,
+                                           body: dict) -> Dict:                              # Auto-generated from endpoint post__data__store_json__with__id_and_key
+                                                                                    # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/store/json/{data_key}/{data_file_id}"
+        #body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "POST",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    #def data__store_string(self, cache_id: str, namespace: str) -> Dict:                             # todo: BUG same as the others
+    def data__store_string(self, cache_id: str, namespace: Safe_Str__Id, body:str) -> Dict:
+                                                                                    # Build path
+        #path = f"/{{namespace}}/cache/{{cache_id}}/data/store/string"              # BUG
+        #body = None
+        path = f"/{namespace}/cache/{cache_id}/data/store/string"
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "POST",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    #def data__store_string__with__id(self, cache_id: str, namespace: str, data_file_id: str) -> Dict:                              # Auto-generated from endpoint post__data__store_string__with__id
+    def data__store_string__with__id(self, cache_id     : str,
+                                           namespace    : Safe_Str__Id,
+                                           data_file_id : Safe_Str__Id,
+                                           body         : str
+                                     ) -> Dict:                              # Auto-generated from endpoint post__data__store_string__with__id
+
+        #path = f"/{{namespace}}/cache/{{cache_id}}/data/store/string/{{data_file_id}}"      # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/store/string/{data_file_id}"      # Build path
+        #body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "POST",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    #def data__store_string__with__id_and_key(self, cache_id: str, namespace: str, data_key: str, data_file_id: str) -> Dict:                              # Auto-generated from endpoint post__data__store_string__with__id_and_key
+    def data__store_string__with__id_and_key(self, cache_id     : str                   ,
+                                                   namespace    : Safe_Str__Id          ,
+                                                   data_key     : Safe_Str__File__Path  ,
+                                                   data_file_id : Safe_Str__Id          ,
+                                                   body: str
+                                             ) -> Dict:                              # Auto-generated from endpoint post__data__store_string__with__id_and_key
+
+        #path = f"/{{namespace}}/cache/{{cache_id}}/data/store/string/{data_key:path}/{{data_file_id}}"  # Build path
+        path = f"/{namespace}/cache/{cache_id}/data/store/string/{data_key}/{data_file_id}"  # Build path
+        #body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "POST",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text

mgraph_ai_service_cache_client/client_contract/delete/Service__Fast_API__Client__File__Delete.py

@@ -0,0 +1,22 @@
+from typing import Any, Optional, Dict
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+class Service__Fast_API__Client__File__Delete(Type_Safe):
+    _client: Any                                                                    # Reference to main client
+
+    @property
+    def requests(self):                                                             # Access the unified request handler
+        return self._client.requests()
+
+    def delete__cache_id(self, cache_id: str, namespace: str) -> Dict:                              # Auto-generated from endpoint delete__delete__cache_id
+                                                                                    # Build path
+        path = f"/{{namespace}}/delete/{{cache_id}}"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "DELETE",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text

mgraph_ai_service_cache_client/client_contract/exists/Service__Fast_API__Client__File__Exists.py

@@ -0,0 +1,22 @@
+from typing import Any, Optional, Dict
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+class Service__Fast_API__Client__File__Exists(Type_Safe):
+    _client: Any                                                                    # Reference to main client
+
+    @property
+    def requests(self):                                                             # Access the unified request handler
+        return self._client.requests()
+
+    def exists__hash__cache_hash(self, cache_hash: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__exists__hash__cache_hash
+                                                                                    # Build path
+        path = f"/{{namespace}}/exists/hash/{{cache_hash}}"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text

mgraph_ai_service_cache_client/client_contract/info/Service__Fast_API__Client__Info.py

@@ -0,0 +1,64 @@
+from typing import Any, Optional, Dict
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+
+class Service__Fast_API__Client__Info(Type_Safe):
+    _client: Any                                                                    # todo: BUG: was Any and started with _
+    #client : Service__Fast_API__Client                                             # todo: BUG: fix circular dependency on Service__Fast_API__Client
+
+    @property
+    def requests(self):                                                             # Access the unified request handler
+        #return self._client.requests()                                             # todo: BUG: used _client
+        return self._client.requests()
+
+    def health(self) -> Dict:                              # Auto-generated from endpoint get__health
+                                                                                    # Build path
+        path = "/info/health"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def server(self) -> Dict:                              # Auto-generated from endpoint get__server
+                                                                                    # Build path
+        path = "/info/server"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def status(self) -> Dict:                              # Auto-generated from endpoint get__status
+                                                                                    # Build path
+        path = "/info/status"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def versions(self) -> Dict:                              # Auto-generated from endpoint get__versions
+                                                                                    # Build path
+        path = "/info/versions"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text

mgraph_ai_service_cache_client/client_contract/namespace/Service__Fast_API__Client__Namespace.py

@@ -0,0 +1,48 @@
+from typing import Any, Optional, Dict
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+class Service__Fast_API__Client__Namespace(Type_Safe):
+    _client: Any                                                                    # Reference to main client
+
+    @property
+    def requests(self):                                                             # Access the unified request handler
+        return self._client.requests()
+
+    def file_hashes(self, namespace: str) -> Dict:                              # Auto-generated from endpoint get__file_hashes
+                                                                                    # Build path
+        path = f"/{{namespace}}/file-hashes"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def file_ids(self, namespace: str) -> Dict:                              # Auto-generated from endpoint get__file_ids
+                                                                                    # Build path
+        path = f"/{{namespace}}/file-ids"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def stats(self, namespace: str) -> Dict:                              # Auto-generated from endpoint get__stats
+                                                                                    # Build path
+        path = f"/{{namespace}}/stats"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text

mgraph_ai_service_cache_client/client_contract/retrieve/Service__Fast_API__Client__File__Retrieve.py

@@ -0,0 +1,169 @@
+from typing import Any, Optional, Dict
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+class Service__Fast_API__Client__File__Retrieve(Type_Safe):
+    _client: Any                                                                    # Reference to main client
+
+    @property
+    def requests(self):                                                             # Access the unified request handler
+        return self._client.requests()
+
+    def retrieve__cache_id(self, cache_id: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__cache_id
+                                                                                    # Build path
+        path = f"/{{namespace}}/retrieve/{{cache_id}}"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def retrieve__cache_id__config(self, cache_id: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__cache_id__config
+                                                                                    # Build path
+        path = f"/{{namespace}}/retrieve/{{cache_id}}/config"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def retrieve__cache_id__metadata(self, cache_id: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__cache_id__metadata
+                                                                                    # Build path
+        path = f"/{{namespace}}/retrieve/{{cache_id}}/metadata"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def retrieve__cache_id__refs(self, cache_id: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__cache_id__refs
+                                                                                    # Build path
+        path = f"/{{namespace}}/retrieve/{{cache_id}}/refs"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def retrieve__cache_id__refs__all(self, cache_id: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__cache_id__refs__all
+                                                                                    # Build path
+        path = f"/{{namespace}}/retrieve/{{cache_id}}/refs/all"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def retrieve__hash__cache_hash(self, cache_hash: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__hash__cache_hash
+                                                                                    # Build path
+        path = f"/{{namespace}}/retrieve/hash/{{cache_hash}}"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def retrieve__cache_id__string(self, cache_id: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__cache_id__string
+                                                                                    # Build path
+        #path = f"/{{namespace}}/retrieve/{{cache_id}}/string"                      # todo: BUG: used {{
+        path = f"/{namespace}/retrieve/{cache_id}/string"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def retrieve__cache_id__json(self, cache_id: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__cache_id__json
+                                                                                    # Build path
+        #path = f"/{{namespace}}/retrieve/{{cache_id}}/json"                        # used {{
+        path = f"/{namespace}/retrieve/{cache_id}/json"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def retrieve__cache_id__binary(self, cache_id: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__cache_id__binary
+                                                                                    # Build path
+        #path = f"/{{namespace}}/retrieve/{{cache_id}}/binary"                      # todo: BUG: used {{
+        path = f"/{namespace}/retrieve/{cache_id}/binary"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        #return result.json if result.json else result.text                         # todo: BUG returned this
+        return result.content                                                       #       and since this is binary we need to return the result.content
+
+    def retrieve__hash__cache_hash__string(self, cache_hash: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__hash__cache_hash__string
+                                                                                    # Build path
+        path = f"/{{namespace}}/retrieve/hash/{{cache_hash}}/string"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def retrieve__hash__cache_hash__json(self, cache_hash: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__hash__cache_hash__json
+                                                                                    # Build path
+        path = f"/{{namespace}}/retrieve/hash/{{cache_hash}}/json"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def retrieve__hash__cache_hash__binary(self, cache_hash: str, namespace: str) -> Dict:                              # Auto-generated from endpoint get__retrieve__hash__cache_hash__binary
+                                                                                    # Build path
+        path = f"/{{namespace}}/retrieve/hash/{{cache_hash}}/binary"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text

mgraph_ai_service_cache_client/client_contract/server/Service__Fast_API__Client__Server.py

@@ -0,0 +1,35 @@
+from typing import Any, Optional, Dict
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+class Service__Fast_API__Client__Server(Type_Safe):
+    _client: Any                                                                    # Reference to main client
+
+    @property
+    def requests(self):                                                             # Access the unified request handler
+        return self._client.requests()
+
+    def storage__info(self) -> Dict:                              # Auto-generated from endpoint get__storage__info
+                                                                                    # Build path
+        path = "/server/storage/info"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text
+
+    def create__test_fixtures(self) -> Dict:                              # Auto-generated from endpoint get__create__test_fixtures
+                                                                                    # Build path
+        path = "/server/create/test-fixtures"
+        body = None
+                                                                                    # Execute request
+        result = self.requests.execute(
+            method = "GET",
+            path   = path,
+            body   = body
+        )
+                                                                                    # Return response data
+        return result.json if result.json else result.text