Merge dev into main

Author: DinisCruz

README.md

@@ -1,6 +1,6 @@
 # OSBot-Fast-API
 
-![Current Release](https://img.shields.io/badge/release-v0.18.0-blue)
+![Current Release](https://img.shields.io/badge/release-v0.18.2-blue)
 ![Python](https://img.shields.io/badge/python-3.8+-green)
 ![FastAPI](https://img.shields.io/badge/FastAPI-0.100+-red)
 ![Type-Safe](https://img.shields.io/badge/Type--Safe-✓-brightgreen)

osbot_fast_api/admin_ui/api/routes/Routes__Admin__Config.py

@@ -42,8 +42,7 @@ def api__routes_grouped(self) -> Dict[str, List[Dict[str, Any]]]:
     def api__middlewares(self) -> List[Dict[str, Any]]:                             # Get middleware information
         if not self.parent_app:
             return []
-
-        return self.parent_app.user_middlewares()
+        return self.parent_app.user_middlewares(include_params=False)
 
     def api__openapi_spec(self) -> Dict[str, Any]:                                  # Get OpenAPI specification
         if not self.parent_app:

osbot_fast_api/admin_ui/api/routes/Routes__Admin__Cookies.py

@@ -30,8 +30,13 @@ class Cookie__Template(Type_Safe):                  # Template for common cookie
     description : str
     cookies     : List[Cookie__Config]
 
-class Cookies__Templates(Type_Safe):
-    cookies_templates : List[Cookie__Template]
+class Cookie__Bulk_Request(Type_Safe):
+    name       : str
+    value      : str
+    expires_in : Optional[int] = None
+
+class Cookies__Bulk_Request(Type_Safe):
+    cookies : List[Cookie__Bulk_Request]
 
 class Routes__Admin__Cookies(Fast_API__Routes):         # API routes for cookie management
     tag        = 'admin-cookies'
@@ -144,7 +149,7 @@ def api__cookies_list(self, request: Request) -> List[Dict[str, Any]]:
     def api__cookies_templates(self) -> List[Dict[str, Any]]:           # Get available cookie templates
         return self.COOKIE_TEMPLATES                                    # todo: see note above in COOKIE_TEMPLATES
 
-    def api__cookie_get(self, cookie_name: str, request: Request) -> Dict[str, Any]:                                    # Get a specific cookie value
+    def api__cookie_get__cookie_name(self, cookie_name: str, request: Request) -> Dict[str, Any]:                                    # Get a specific cookie value
         value = request.cookies.get(cookie_name)
 
         config = None                                                                                                   # Find cookie config
@@ -193,33 +198,33 @@ def api__cookie_set__cookie_name(self, cookie_name   : str           ,
                  "name"     : cookie_name                   ,                                                           #       we also need to standardise the return object/class
                  "value_set": len(cookie_value.value) > 0   }
 
-    def api__cookie_delete(self, cookie_name: str, response: Response) -> Dict[str, Any]:                               # Delete a cookie
+    def api__cookie_delete__cookie_name(self, cookie_name: str, response: Response) -> Dict[str, Any]:                               # Delete a cookie
         response.delete_cookie(key=cookie_name)
 
         return { "success"  : True       ,                                                                              # todo: convert this to a Schema_* class
                  "name"     : cookie_name,
                  "deleted"  : True       }
 
-    def api__cookies_bulk_set(self, cookies_templates : Cookies__Templates, #cookies: List[Dict[str, str]],
-                                    request           : Request           ,
-                                    response          : Response
+    def api__cookies_bulk_set(self, bulk_request : Cookies__Bulk_Request, #cookies: List[Dict[str, str]],
+                                    request      : Request           ,
+                                    response     : Response
                                ) -> Dict[str, Any]:        # Set multiple cookies at once"""
         results = []
 
-        for cookie_data in cookies_templates:
-            cookie_name = cookie_data.get('name')
-            cookie_value = Cookie__Value(value=cookie_data.get('value', ''))
+        for cookie_data in bulk_request.cookies:
+            cookie_name       = cookie_data.name
+            cookie_value      = Cookie__Value(value=cookie_data.value , expires_in=cookie_data.expires_in)
 
             if cookie_name:
-                result = self.api__cookie_set(cookie_name, cookie_value, request, response)
+                result = self.api__cookie_set__cookie_name(cookie_name, cookie_value, request, response)
                 results.append(result)
 
         return {
             "success": all(r.get('success') for r in results),
             "results": results
         }
 
-    def api__generate_value(self, value_type: str = "uuid") -> Dict[str, str]:
+    def api__generate_value__value_type(self, value_type: str = "uuid") -> Dict[str, str]:
         """Generate a value for cookies (UUID, random string, etc.)"""
         if value_type == "uuid":
             return {"value": random_guid(), "type": "uuid"}
@@ -245,10 +250,10 @@ def _validate_cookie_value(self, value: Optional[str], pattern: Optional[str]) -
             return True
 
     def setup_routes(self):
-        self.add_route_get   (self.api__cookies_list            )
-        self.add_route_get   (self.api__cookies_templates       )
-        self.add_route_get   (self.api__cookie_get              )
-        self.add_route_post  (self.api__cookie_set__cookie_name )
-        self.add_route_delete(self.api__cookie_delete           )
-        self.add_route_post  (self.api__cookies_bulk_set        )
-        self.add_route_get   (self.api__generate_value          )
+        self.add_route_get   (self.api__cookies_list              )
+        self.add_route_get   (self.api__cookies_templates         )
+        self.add_route_get   (self.api__cookie_get__cookie_name   )
+        self.add_route_post  (self.api__cookie_set__cookie_name   )
+        self.add_route_delete(self.api__cookie_delete__cookie_name)
+        self.add_route_post  (self.api__cookies_bulk_set          )
+        self.add_route_get   (self.api__generate_value__value_type            )

osbot_fast_api/admin_ui/api/routes/Routes__Admin__Docs.py

@@ -123,8 +123,6 @@ def api__client_examples(self) -> Dict[str, Any]:           # Get client code ex
         return examples
 
     def api__api_info(self) -> Dict[str, Any]:                                                                          # Get API metadata and information
-        if not self.parent_app:
-            return {"error": "Parent app not configured"}
 
         openapi = self.parent_app.open_api_json()
 

osbot_fast_api/admin_ui/api/routes/Routes__Admin__Info.py

@@ -10,17 +10,15 @@ class Routes__Admin__Info(Fast_API__Routes):        # API routes for admin dashb
     parent_app = None                               # Will be set by Admin_UI__Fast_API
 
     def api__server_info(self) -> Dict[str, Any]:           # Get server information # todo: convert this object to Schema__Fast_API__Admin__Server_Info
-        return { "server_id"         : str(fast_api__server_info.server_id),
-                 "server_name"       : str(fast_api__server_info.server_name) if fast_api__server_info.server_name else "unnamed",
-                 "server_instance_id": str(fast_api__server_info.server_instance_id),
+        return { "server_id"         : fast_api__server_info.server_id   or ''       ,
+                 "server_name"       : fast_api__server_info.server_name or "unnamed",
+                 "server_instance_id": fast_api__server_info.server_instance_id,
                  "server_boot_time"  : int(fast_api__server_info.server_boot_time),
                  "current_time"      : timestamp_utc_now(),
                  "uptime_ms"         : timestamp_utc_now() - int(fast_api__server_info.server_boot_time)         # double check this calculation
         }
 
     def api__app_info(self) -> Dict[str, Any]:              # Get FastAPI application information # todo: convert this object to Schema__Fast_API__Admin__App_Info
-        if not self.parent_app:
-            return {"error": "Parent app not configured"}
 
         return { "name"       : self.parent_app.name              ,
                  "version"    : self.parent_app.version           ,
@@ -31,8 +29,6 @@ def api__app_info(self) -> Dict[str, Any]:              # Get FastAPI applicatio
                  "enable_api_key": self.parent_app.enable_api_key }
 
     def api__stats(self) -> Dict[str, Any]:                                     # Get application statistics
-        if not self.parent_app:
-            return {"error": "Parent app not configured"}
 
         routes = self.parent_app.routes(include_default=False, expand_mounts=True)
 

osbot_fast_api/admin_ui/static/js/admin_ui.js

@@ -236,7 +236,7 @@ export class AdminUI {
     }
 
     async generateValue(type = 'uuid') {
-        return await this.apiCall(`/admin-cookies/api/generate-value?value_type=${type}`);
+        return await this.apiCall(`/admin-cookies/api/generate-value/${type}`);
     }
 
     // Utility Methods

osbot_fast_api/admin_ui/static/js/components/cookie_editor.js

@@ -948,7 +948,7 @@ class CookieEditor extends HTMLElement {
 
     async generateValue(type) {
         try {
-            const response = await fetch(`${this.apiBase}/generate-value?value_type=${type}`);
+            const response = await fetch(`${this.apiBase}/generate-value/${type}`);
             const result = await response.json();
 
             if (result.value) {

osbot_fast_api/api/Fast_API.py

@@ -247,7 +247,7 @@ def setup_middleware__http_events(self):
         return self
 
 
-    def user_middlewares(self):
+    def user_middlewares(self, include_params=True):
         import types
 
         middlewares = []
@@ -261,8 +261,9 @@ def user_middlewares(self):
                 else:
                     function_name = None
                 middleware = { 'type'         : type_name     ,
-                               'function_name': function_name ,
-                               'params'       : options       }
+                               'function_name': function_name }
+                if include_params:
+                    middleware['params'] = options
                 middlewares.append(middleware)
         return middlewares
 

osbot_fast_api/utils/Fast_API_Server.py

@@ -66,19 +66,24 @@ def stop(self):
         self.running = False
         return result
 
+    def requests_delete(self, path='', **kwargs):
+        url = url_join_safe(self.url(), path)
+        return requests.delete(url, **kwargs)
+
     def requests_get(self, path='', **kwargs):
         url = url_join_safe(self.url(), path)
         return requests.get(url, **kwargs)
 
-    def requests_post(self, path='', data=None):
-        if Type_Safe in base_types(data):
-            json_data = data.json()
-        elif type(data) is dict:
-            json_data = data
-        else:
-            raise ValueError("data must be a Type_Safe or a dict")
+    def requests_post(self, path='', data=None, json=None, **kwargs):
+        if json is None:
+            if Type_Safe in base_types(data):
+                json = data.json()
+            elif type(data) is dict:
+                json = data
+            else:
+                raise ValueError("data must be a Type_Safe or a dict")
         url = urljoin(self.url(), path)
-        return requests.post(url, json=json_data)
+        return requests.post(url, json=json, **kwargs)
 
     def url(self):
         return f'http://{FAST_API__HOST}:{self.port}/'

osbot_fast_api/utils/Fast_API__Server_Info.py

@@ -14,4 +14,5 @@ class Fast_API__Server_Info(Type_Safe):
     server_instance_id: Random_Guid
     server_boot_time  : Timestamp_Now
 
+
 fast_api__server_info = Fast_API__Server_Info()