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

mgraph_ai_service_cache_client/client/Cache__Client.py

@@ -0,0 +1,6 @@
+from osbot_utils.type_safe.Type_Safe                             import Type_Safe
+from mgraph_ai_service_cache_client.client.Cache__Client__Config import Cache__Client__Config
+
+
+class Cache__Client(Type_Safe):
+    config: Cache__Client__Config

mgraph_ai_service_cache_client/client/Cache__Client__Config.py

@@ -0,0 +1,7 @@
+from osbot_utils.type_safe.Type_Safe                                     import Type_Safe
+from osbot_utils.type_safe.primitives.domains.web.safe_str.Safe_Str__Url import Safe_Str__Url
+
+URL__TARGET_SERVER__DEV = "https://cache.dev.mgraph.ai"
+
+class Cache__Client__Config(Type_Safe):
+    target_server : Safe_Str__Url = URL__TARGET_SERVER__DEV

mgraph_ai_service_cache_client/client/Cache__Client__Health_Checks.py

@@ -0,0 +1,38 @@
+from osbot_utils.decorators.methods.cache_on_self                                                     import cache_on_self
+from osbot_utils.type_safe.Type_Safe                                                                  import Type_Safe
+from osbot_utils.utils.Misc                                                                           import list_set
+from mgraph_ai_service_cache_client.client.Cache__Client__Config                                      import Cache__Client__Config
+from mgraph_ai_service_cache_client.client.Cache__Client__Requests                                    import Cache__Client__Requests
+from mgraph_ai_service_cache_client.schemas.client.health_checks.Client__Check__Target_Server__Status import Client__Check__Target_Server__Status
+from mgraph_ai_service_cache_client.schemas.client.health_checks.Client__Check__Target_Server__Auth   import Client__Check__Target_Server__Auth
+
+
+class Cache__Client__Health_Checks(Type_Safe):
+    config : Cache__Client__Config
+
+    @cache_on_self
+    def client__requests(self):
+        return Cache__Client__Requests(config=self.config)
+
+    def check__target_server__status(self) -> Client__Check__Target_Server__Status:
+        path          = "/openapi.json"                                  # in Fast_API this endpoint has no auth
+        result        = self.client__requests().get(path)
+        openapi_json  = result.json
+        success       = list_set(openapi_json) == ['components', 'info', 'openapi', 'paths']
+
+        status_kwargs = dict(duration      = result.duration          ,
+                             success       = success                   ,
+                             target_server = self.config.target_server)
+        return Client__Check__Target_Server__Status(**status_kwargs)
+
+    def check__target_server__auth(self) -> Client__Check__Target_Server__Auth:
+        with self.client__requests() as _:
+            found_key_name             = _.auth__key_name () is not None
+            found_key_value            = _.auth__key_value() is not None
+            path                       = '/info/health'
+            result                     = self.client__requests().get(path)
+            key_valid_in_target_server = result.json == {'status': 'ok'}
+            auth_kwargs                = dict(found_key_name             = found_key_name ,
+                                              found_key_value            = found_key_value,
+                                              key_valid_in_target_server = key_valid_in_target_server)
+            return Client__Check__Target_Server__Auth(**auth_kwargs)

mgraph_ai_service_cache_client/client/Cache__Client__Requests.py

@@ -0,0 +1,50 @@
+import requests
+from osbot_utils.helpers.duration.decorators.capture_duration                       import capture_duration
+from osbot_utils.type_safe.Type_Safe                                                import Type_Safe
+from osbot_utils.utils.Env                                                          import get_env
+from osbot_utils.utils.Http                                                         import url_join_safe
+from mgraph_ai_service_cache_client.client.Cache__Client__Config                    import Cache__Client__Config
+from mgraph_ai_service_cache_client.schemas.client.Cache__Client__Requests__Result  import Cache__Client__Requests__Result
+from mgraph_ai_service_cache_client.schemas.consts.consts__Cache_Client             import ENV_VAR__AUTH__TARGET_SERVER__CACHE_SERVICE__KEY_NAME, ENV_VAR__AUTH__TARGET_SERVER__CACHE_SERVICE__KEY_VALUE
+
+
+class Cache__Client__Requests(Type_Safe):
+    config: Cache__Client__Config
+
+    def auth__key_name(self):
+        return get_env(ENV_VAR__AUTH__TARGET_SERVER__CACHE_SERVICE__KEY_NAME)
+
+    def auth__key_value(self):
+        return get_env(ENV_VAR__AUTH__TARGET_SERVER__CACHE_SERVICE__KEY_VALUE)
+
+    def auth_headers(self):
+        key_name  =  self.auth__key_name()
+        key_value = self.auth__key_value()
+        if key_name and key_value:
+            return { key_name: key_value }
+        return {}
+
+    def headers(self):
+        return { **self.auth_headers() }                                    # location to add more requests headers (if needed)
+
+    def get(self, path):
+        target_server = self.config.target_server
+        url           = url_join_safe(target_server, path)
+        headers       = self.auth_headers()
+        with capture_duration() as duration:
+            response      = requests.get(url, headers=headers)
+
+
+        content_type  = response.headers.get('content-type')
+        result_kwargs = dict(content_type  = content_type        ,
+                             duration      = duration.seconds    ,
+                             path          = path                ,
+                             status_code   = response.status_code,
+                             target_server = target_server       )
+
+        if   'json' in content_type:  result_kwargs['json'   ] = response.json()
+        elif 'text' in content_type:  result_kwargs['text'   ] = response.text
+        else:                         result_kwargs['content'] = response.content
+
+        return Cache__Client__Requests__Result(**result_kwargs)
+

mgraph_ai_service_cache_client/client_builder/Fast_API__Client__Builder.py

@@ -0,0 +1,49 @@
+from osbot_fast_api.client.Fast_API__Client__Generator                                               import Fast_API__Client__Generator
+from osbot_utils.type_safe.Type_Safe                                                                 import Type_Safe
+from osbot_utils.type_safe.type_safe_core.decorators.type_safe                                       import type_safe
+from osbot_utils.utils.Env                                                                           import get_env
+from mgraph_ai_service_cache.fast_api.Service__Fast_API                                              import Service__Fast_API
+from mgraph_ai_service_cache_client                                                                  import client_contract
+from mgraph_ai_service_cache_client.client_contract.Service__Fast_API__Client                        import Service__Fast_API__Client
+from mgraph_ai_service_cache_client.schemas.client_builder.Schema__Fast_API__Client__Server__Details import Schema__Fast_API__Client__Server__Details
+from mgraph_ai_service_cache_client.schemas.consts.consts__Cache_Client                              import ENV_VAR__AUTH__TARGET_SERVER__CACHE_SERVICE__KEY_VALUE, ENV_VAR__AUTH__TARGET_SERVER__CACHE_SERVICE__KEY_NAME, ENV_VAR__URL__TARGET_SERVER__CACHE_SERVICE
+
+
+class Fast_API__Client__Builder(Type_Safe):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.cache_service__fast_api = Service__Fast_API().setup()
+        self.generator               = Fast_API__Client__Generator(fast_api=self.cache_service__fast_api)
+
+    def create_client_files(self):
+        with self.generator as _:
+            output_dir  = self.target_folder()
+            saved_files = _.save_client_files(output_dir=output_dir)
+            return sorted(saved_files)
+
+    def target_folder(self):
+        return client_contract.path
+
+    @type_safe
+    def configure_client(self, service_client: Service__Fast_API__Client):
+        with self.server_details() as _:
+            if _.configured:
+                service_client.config.api_key        = _.api_key
+                service_client.config.api_key_header = _.api_key_header
+                service_client.config.base_url       = _.base_url
+            return _
+
+    def server_details(self) -> Schema__Fast_API__Client__Server__Details:
+        api_key        = get_env(ENV_VAR__AUTH__TARGET_SERVER__CACHE_SERVICE__KEY_VALUE)
+        api_key_header = get_env(ENV_VAR__AUTH__TARGET_SERVER__CACHE_SERVICE__KEY_NAME )
+        base_url       = get_env(ENV_VAR__URL__TARGET_SERVER__CACHE_SERVICE            )
+        configured     = all([api_key, api_key_header, base_url])
+
+        kwargs = dict(api_key        = api_key          ,
+                      api_key_header = api_key_header   ,
+                      base_url       = base_url         ,
+                      configured     = configured       )
+        return Schema__Fast_API__Client__Server__Details(**kwargs)
+
+

mgraph_ai_service_cache_client/client_contract/Service__Fast_API__Client.py

@@ -0,0 +1,77 @@
+from osbot_utils.type_safe.Type_Safe                          import Type_Safe
+from osbot_utils.decorators.methods.cache_on_self             import cache_on_self
+from .Service__Fast_API__Client__Config                       import Service__Fast_API__Client__Config
+from .Service__Fast_API__Client__Requests                     import Service__Fast_API__Client__Requests
+from .store.Service__Fast_API__Client__File__Store            import Service__Fast_API__Client__File__Store
+from .retrieve.Service__Fast_API__Client__File__Retrieve      import Service__Fast_API__Client__File__Retrieve
+from .exists.Service__Fast_API__Client__File__Exists          import Service__Fast_API__Client__File__Exists
+from .delete.Service__Fast_API__Client__File__Delete          import Service__Fast_API__Client__File__Delete
+from .data_store.Service__Fast_API__Client__Data__Store       import Service__Fast_API__Client__Data__Store
+from .data.Service__Fast_API__Client__Data                    import Service__Fast_API__Client__Data
+from .zip.Service__Fast_API__Client__Zip                      import Service__Fast_API__Client__Zip
+from .namespace.Service__Fast_API__Client__Namespace          import Service__Fast_API__Client__Namespace
+from .admin_storage.Service__Fast_API__Client__Admin__Storage import Service__Fast_API__Client__Admin__Storage
+from .server.Service__Fast_API__Client__Server                import Service__Fast_API__Client__Server
+from .info.Service__Fast_API__Client__Info                    import Service__Fast_API__Client__Info
+#from .auth.Service__Fast_API__Client__Auth                  import Service__Fast_API__Client__Auth     # todo see why this is added here (but file is not created on disk)
+
+class Service__Fast_API__Client(Type_Safe):
+    config   : Service__Fast_API__Client__Config
+    _requests: Service__Fast_API__Client__Requests = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)                                                 # Initialize request handler with config
+        if not self._requests:
+            self._requests = Service__Fast_API__Client__Requests(config=self.config)
+
+    @cache_on_self
+    def requests(self) -> Service__Fast_API__Client__Requests:                            # Access the unified request handler
+        return self._requests
+
+    @cache_on_self
+    def store(self) -> Service__Fast_API__Client__File__Store:                               # Access store operations
+        return Service__Fast_API__Client__File__Store(_client=self)
+
+    @cache_on_self
+    def retrieve(self) -> Service__Fast_API__Client__File__Retrieve:                               # Access retrieve operations
+        return Service__Fast_API__Client__File__Retrieve(_client=self)
+
+    @cache_on_self
+    def exists(self) -> Service__Fast_API__Client__File__Exists:                               # Access exists operations
+        return Service__Fast_API__Client__File__Exists(_client=self)
+
+    @cache_on_self
+    def delete(self) -> Service__Fast_API__Client__File__Delete:                               # Access delete operations
+        return Service__Fast_API__Client__File__Delete(_client=self)
+
+    @cache_on_self
+    def data_store(self) -> Service__Fast_API__Client__Data__Store:                               # Access data_store operations
+        return Service__Fast_API__Client__Data__Store(_client=self)
+
+    @cache_on_self
+    def data(self) -> Service__Fast_API__Client__Data:                               # Access data operations
+        return Service__Fast_API__Client__Data(_client=self)
+
+    @cache_on_self
+    def zip(self) -> Service__Fast_API__Client__Zip:                               # Access zip operations
+        return Service__Fast_API__Client__Zip(_client=self)
+
+    @cache_on_self
+    def namespace(self) -> Service__Fast_API__Client__Namespace:                               # Access namespace operations
+        return Service__Fast_API__Client__Namespace(_client=self)
+
+    @cache_on_self
+    def admin_storage(self) -> Service__Fast_API__Client__Admin__Storage:                               # Access admin_storage operations
+        return Service__Fast_API__Client__Admin__Storage(_client=self)
+
+    @cache_on_self
+    def server(self) -> Service__Fast_API__Client__Server:                               # Access server operations
+        return Service__Fast_API__Client__Server(_client=self)
+
+    @cache_on_self
+    def info(self) -> Service__Fast_API__Client__Info:                               # Access info operations
+        return Service__Fast_API__Client__Info(_client=self)
+
+    # @cache_on_self
+    # def auth(self) -> Service__Fast_API__Client__Auth:                               # Access auth operations
+    #     return Service__Fast_API__Client__Auth(_client=self)

mgraph_ai_service_cache_client/client_contract/Service__Fast_API__Client__Config.py

@@ -0,0 +1,14 @@
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+from osbot_utils.type_safe.primitives.domains.web.safe_str.Safe_Str__Url import Safe_Str__Url
+from osbot_utils.type_safe.primitives.domains.identifiers.safe_str.Safe_Str__Id import Safe_Str__Id
+from typing import Optional
+
+class Service__Fast_API__Client__Config(Type_Safe):
+    base_url        : Safe_Str__Url = "http://localhost:8000"                      # Default to local
+    api_key         : Optional[str] = None                                         # Optional API key
+    api_key_header  : str           = "X-API-Key"                                  # Header name for API key
+    timeout         : int           = 30                                           # Request timeout in seconds
+    verify_ssl      : bool          = True                                         # Verify SSL certificates
+                                                                                    # Service-specific configuration can be added here
+    service_name    : Safe_Str__Id  = "Service__Fast_API"
+    service_version : str           = "v0.5.67"

mgraph_ai_service_cache_client/client_contract/Service__Fast_API__Client__Requests.py

@@ -0,0 +1,146 @@
+from enum import Enum
+from typing import Any, Optional, Dict, Union, List
+import requests
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+class Enum__Client__Mode(str, Enum):
+    REMOTE       = "remote"                                                        # HTTP calls to deployed service
+    IN_MEMORY    = "in_memory"                                                     # FastAPI TestClient (same process)
+    LOCAL_SERVER = "local_server"                                                  # Fast_API_Server (local HTTP)
+
+class Service__Fast_API__Client__Requests__Result(Type_Safe):
+    status_code : int
+    #json        : Optional[Dict] = None                                            # BUG, mising list
+    json        : Union[Dict,List] = None
+    text        : Optional[str]    = None
+    content     : bytes            = b""
+    #headers     : Dict[str, str] = {}                                              # BUG: we can't do this with Type_Safe (this will be allocated on __init__)
+    headers     : Dict[str, str]
+    path        : str            = ""
+
+class Service__Fast_API__Client__Requests(Type_Safe):
+    config       : Any                                                             # Service__Fast_API__Client__Config
+    mode         : Enum__Client__Mode         = Enum__Client__Mode.REMOTE
+    _app         : Optional[Any]              = None                               # FastAPI app for in-memory
+    _server      : Optional[Any]              = None                               # Fast_API_Server for local
+    _test_client : Optional[Any]              = None                               # TestClient for in-memory
+    _session     : Optional[requests.Session] = None                               # Session for remote
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._setup_mode()
+
+    def _setup_mode(self):                                                         # Initialize the appropriate execution backend
+
+        if self._app:                                                              # In-memory mode with TestClient
+            self.mode = Enum__Client__Mode.IN_MEMORY
+            from fastapi.testclient import TestClient
+            self._test_client = TestClient(self._app)
+
+        elif self._server:                                                         # Local server mode
+            self.mode = Enum__Client__Mode.LOCAL_SERVER
+            from osbot_fast_api.utils.Fast_API_Server import Fast_API_Server
+            if not isinstance(self._server, Fast_API_Server):
+                self._server = Fast_API_Server(app=self._server)
+                self._server.start()
+
+        else:                                                                      # Remote mode
+            self.mode     = Enum__Client__Mode.REMOTE
+            self._session = requests.Session()
+            self._configure_session()
+
+    def _configure_session(self):                                                  # Configure session for remote calls
+        if self._session:                                                          # Add any auth headers from config
+            if hasattr(self.config, 'api_key') and self.config.api_key:
+                self._session.headers['Authorization'] = f'Bearer {self.config.api_key}'
+
+    def execute(self, method  : str              ,                                 # HTTP method (GET, POST, etc)
+                     path     : str              ,                                 # Endpoint path
+                     body     : Any        = None,                                 # Request body
+                     headers  : Optional[Dict] = None                              # Additional headers
+               ) -> Service__Fast_API__Client__Requests__Result:                          # Execute request transparently based on mode
+                                                                                    # Merge headers
+        request_headers = {**self.auth_headers(), **(headers or {})}
+                                                                                    # Execute based on mode
+        if self.mode == Enum__Client__Mode.IN_MEMORY:
+            response = self._execute_in_memory(method, path, body, request_headers)
+        elif self.mode == Enum__Client__Mode.LOCAL_SERVER:
+            response = self._execute_local_server(method, path, body, request_headers)
+        else:
+            response = self._execute_remote(method, path, body, request_headers)
+                                                                                    # Convert to unified result
+        return self._build_result(response, path)
+
+    def _execute_in_memory(self, method  : str  ,                                  # HTTP method
+                                path     : str  ,                                  # Endpoint path
+                                body     : Any  ,                                  # Request body
+                                headers  : Dict                                    # Headers
+                         ):                                                        # Execute using FastAPI TestClient
+        method_func = getattr(self._test_client, method.lower())
+        if body:
+            return method_func(path, json=body, headers=headers)
+        else:
+            return method_func(path, headers=headers)
+
+    def _execute_local_server(self, method  : str  ,                               # HTTP method
+                                   path     : str  ,                               # Endpoint path
+                                   body     : Any  ,                               # Request body
+                                   headers  : Dict                                 # Headers
+                            ):                                                     # Execute using local Fast_API_Server
+        url         = f"{self._server.url()}{path}"
+        method_func = getattr(requests, method.lower())
+        if body:
+            return method_func(url, json=body, headers=headers)
+        else:
+            return method_func(url, headers=headers)
+
+    def _execute_remote(self, method  : str  ,                                     # HTTP method
+                             path     : str  ,                                     # Endpoint path
+                             body     : Any  ,                                     # Request body
+                             headers  : Dict                                       # Headers
+                      ):                                                           # Execute using requests to remote service
+        url         = f"{self.config.base_url}{path}"
+        method_func = getattr(self._session, method.lower())
+        if body:
+            if type(body) is bytes:                                                 # todo: BUG need to support submitting bytes like how we are doing here
+                headers["Content-Type"]=  "application/octet-stream"                #       we also need to set this content header
+                return method_func(url, data=body, headers=headers)                 #
+            else:                                                                   #
+                return method_func(url, json=body, headers=headers)
+        else:
+            return method_func(url, headers=headers)
+
+    def _build_result(self, response ,                                             # Response object
+                           path                                                    # Path requested
+                    ) -> Service__Fast_API__Client__Requests__Result:                     # Convert any response type to unified result
+
+        json_data = None
+        text_data = None
+                                                                                    # Try to extract JSON
+        try:
+            json_data = response.json()
+        except:
+            pass
+                                                                                    # Try to extract text
+        try:
+            text_data = response.text
+        except:
+            pass
+
+        return Service__Fast_API__Client__Requests__Result(
+            status_code = response.status_code                                   ,
+            json        = json_data                                             ,
+            text        = text_data                                             ,
+            content     = response.content if hasattr(response, 'content') else b"",
+            headers     = dict(response.headers) if hasattr(response, 'headers') else {},
+            path        = path
+        )
+
+    def auth_headers(self) -> Dict[str, str]:                                      # Get authentication headers from config
+        headers = {}
+                                                                                    # Add API key if configured
+        if hasattr(self.config, 'api_key_header') and hasattr(self.config, 'api_key'):
+            if self.config.api_key_header and self.config.api_key:
+                headers[self.config.api_key_header] = self.config.api_key
+
+        return headers

mgraph_ai_service_cache_client/client_contract/__init__.py

@@ -0,0 +1 @@
+path         = __path__[0]

mgraph_ai_service_cache_client/client_contract/admin_storage/Service__Fast_API__Client__Admin__Storage.py

@@ -0,0 +1,113 @@
+from typing import Any, Optional, Dict
+from osbot_utils.type_safe.Type_Safe import Type_Safe
+
+class Service__Fast_API__Client__Admin__Storage(Type_Safe):
+    _client: Any                                                                    # Reference to main client
+
+    @property
+    def requests(self):                                                             # Access the unified request handler
+        return self._client.requests()
+
+    def bucket_name(self) -> Dict:                              # Auto-generated from endpoint get__bucket_name
+                                                                                    # Build path
+        path = "/admin/storage/bucket-name"
+        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__exists(self, path: Any) -> Dict:                              # Auto-generated from endpoint get__file__exists
+                                                                                    # Build path
+        path = f"/admin/storage/file/exists/{path:path}"
+        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__bytes(self, path: Any) -> Dict:                              # Auto-generated from endpoint get__file__bytes
+                                                                                    # Build path
+        path = f"/admin/storage/file/bytes/{path:path}"
+        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__json(self, path: Any) -> Dict:                              # Auto-generated from endpoint get__file__json
+                                                                                    # Build path
+        path = f"/admin/storage/file/json/{path:path}"
+        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 files__parent_path(self, path: Optional[str] = None, return_full_path: Optional[bool] = None) -> Dict:                              # Auto-generated from endpoint get__files__parent_path
+                                                                                    # Build path
+        path = "/admin/storage/files/parent-path"
+        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 files__all__path(self, path: str) -> Dict:                              # Auto-generated from endpoint get__files__all__path
+                                                                                    # Build path
+        path = f"/admin/storage/files/all/{path:path}"
+        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 folders(self, path: Optional[str] = None, return_full_path: Optional[bool] = None) -> Dict:                              # Auto-generated from endpoint get__folders
+                                                                                    # Build path
+        path = "/admin/storage/folders"
+        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 delete__file(self, path: str) -> Dict:                              # Auto-generated from endpoint delete__delete__file
+                                                                                    # Build path
+        path = f"/admin/storage/{path:path}"
+        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/auth/Service__Fast_API__Client__Set_Cookie.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__Set_Cookie(Type_Safe):
+    _client: Any                                                                    # Reference to main client
+
+    @property
+    def requests(self):                                                             # Access the unified request handler
+        return self._client.requests()
+
+    def set_cookie_form(self) -> Dict:                              # Auto-generated from endpoint get__set_cookie_form
+                                                                                    # Build path
+        path = "/auth/set-cookie-form"
+        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 set_auth_cookie(self) -> Dict:                              # Auto-generated from endpoint post__set_auth_cookie
+                                                                                    # Build path
+        path = "/auth/set-auth-cookie"
+        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/data/Service__Fast_API__Client__Data.py

@@ -0,0 +1,17 @@
+from typing                                         import Any
+from osbot_utils.type_safe.Type_Safe                import Type_Safe
+from osbot_utils.decorators.methods.cache_on_self   import cache_on_self
+from .Service__Fast_API__Client__Data__Retrieve     import Service__Fast_API__Client__Data__Retrieve
+from .Service__Fast_API__Client__Data__Delete       import Service__Fast_API__Client__Data__Delete
+
+class Service__Fast_API__Client__Data(Type_Safe):
+    _client: Any                                                                    # Reference to main client
+
+    @cache_on_self
+    def retrieve(self) -> Service__Fast_API__Client__Data__Retrieve:                                  # Access retrieve operations
+        return Service__Fast_API__Client__Data__Retrieve(_client=self._client)
+
+    @cache_on_self
+    def delete(self) -> Service__Fast_API__Client__Data__Delete:                                  # Access delete operations
+        return Service__Fast_API__Client__Data__Delete(_client=self._client)
+

mgraph_ai_service_cache_client/client_contract/data/Service__Fast_API__Client__Data__Delete.py

@@ -0,0 +1,63 @@
+from typing                                                                    import Any, Dict
+from osbot_utils.type_safe.Type_Safe                                           import Type_Safe
+from mgraph_ai_service_cache_client.schemas.cache.enums.Enum__Cache__Data_Type import Enum__Cache__Data_Type
+
+
+class Service__Fast_API__Client__Data__Delete(Type_Safe):
+    _client: Any                                                                    # Reference to main client
+
+    @property
+    def requests(self):                                                             # Access the unified request handler
+        return self._client.requests()
+
+    def delete__all__data__files(self, cache_id: str, namespace: str) -> Dict:                              # Auto-generated from endpoint delete__delete__all__data__files
+                                                                                    # Build path
+        path = f"/{{namespace}}/cache/{{cache_id}}/data/delete/all"
+        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
+
+    def delete__all__data__files__with__key(self, cache_id: str, namespace: str, data_key: str) -> Dict:                              # Auto-generated from endpoint delete__delete__all__data__files__with__key
+                                                                                    # Build path
+        path = f"/{{namespace}}/cache/{{cache_id}}/data/delete/all/{data_key:path}"
+        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
+
+    def delete__data__file__with__id(self, cache_id: str, namespace: str, data_type: Enum__Cache__Data_Type, data_file_id: str) -> Dict:                              # Auto-generated from endpoint delete__delete__data__file__with__id
+                                                                                    # Build path
+        path = f"/{{namespace}}/cache/{{cache_id}}/data/delete/{{data_type}}/{{data_file_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
+
+    def delete__data__file__with__id_and_key(self, cache_id: str, namespace: str, data_type: Enum__Cache__Data_Type, data_key: str, data_file_id: str) -> Dict:                              # Auto-generated from endpoint delete__delete__data__file__with__id_and_key
+                                                                                    # Build path
+        path = f"/{{namespace}}/cache/{{cache_id}}/data/delete/{{data_type}}/{data_key:path}/{{data_file_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