kisa-utils 0.36.2__py3-none-any.whl → 0.36.4__py3-none-any.whl

kisa_utils/functionUtils.py

@@ -6,7 +6,7 @@ from kisa_utils.response import Response, Ok, Error
 from kisa_utils.storage import Path
 from kisa_utils.structures.validator import Value, validateWithResponse
 import copy
-from typing import Any
+from typing import Any, get_args
 
 class Definition:
     @staticmethod
@@ -63,7 +63,7 @@ def enforceRequirements(func):
         typeHints = func.__annotations__
         parameters = signature.parameters
 
-        if not func.__doc__:
+        if not func.__doc__.strip():
             raise ValueError(
                 f"function `{func.__name__}` has no docString!")
 
@@ -83,7 +83,8 @@ def enforceRequirements(func):
                 if value.default is not inspect.Parameter.empty:
                     if not (resp := validateWithResponse(value.default, typeHints[key])):
                         raise ValueError(f'arg `{key}` default value: {resp.log}')
-                registeredArgs.append((key, typeHints[key]))
+
+                registeredArgs.append((key, typeHints[key] ))
             elif value.kind == inspect.Parameter.KEYWORD_ONLY:
                 if value.default is not inspect.Parameter.empty:
                     if not (resp := validateWithResponse(value.default, typeHints[key])):
@@ -100,6 +101,8 @@ def enforceRequirements(func):
 
         expectectedReturnType = typeHints['return']
 
+        # print(registeredArgs, registeredKwargs)
+
     @wraps(func)
     def w(*args, **kwargs):
         for index, arg in enumerate(args):
@@ -120,14 +123,19 @@ def enforceRequirements(func):
 
         resp = func(*args, **kwargs)
 
-        if not isinstance(resp, expectectedReturnType):
-            if isinstance(resp, type):
-                log = f'`{func.__name__}` returned `{resp.__name__}`, expected `{expectectedReturnType}`'
-            else:
-                log = f'`{func.__name__}` returned `{type(resp).__name__}`, expected `{expectectedReturnType}`'
-            
+        # if not isinstance(resp, expectectedReturnType):
+        if not (resp := validateWithResponse(resp, expectectedReturnType)):
             if Response == expectectedReturnType: return Error(log)
-            raise TypeError(log)
+
+            raise TypeError(f'`{func.__name__}` return error: {resp.log}')
+
+            # if isinstance(resp, type):
+            #     log = f'`{func.__name__}` returned `{resp.__name__}`, expected `{expectectedReturnType}`'
+            # else:
+            #     log = f'`{func.__name__}` returned `{type(resp).__name__}`, expected `{expectectedReturnType}`'
+            
+            # if Response == expectectedReturnType: return Error(log)
+            # raise TypeError(log)
 
         return resp
 

kisa_utils/servers/flask.py

@@ -5,7 +5,7 @@ Kisa Server Utilities
 import kisa_utils as kutils
 from kisa_utils.storage import Path
 from kisa_utils.response import Response, Ok, Error
-from flask import Flask, request, jsonify, wrappers, render_template_string
+from flask import Flask, request, jsonify, wrappers, render_template_string, current_app, g as app_ctx
 from flask_cors import CORS
 from functools import wraps
 import copy
@@ -25,6 +25,7 @@ import types
 
 
 _VALID_HTTP_METHODS = {'GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'}
+_WHITE_LISTED_PARAMS = ["headers"]
 
 from typing import Optional, Callable
 from functools import wraps
@@ -42,6 +43,27 @@ def __init():
     globals()['__SERVER_APP'] = __app
     globals()['__BASIC_AUTH'] = __basic_auth
 
+    # change logger to include time spend on a request
+    import logging, logging.handlers, time
+    logging.getLogger('werkzeug').setLevel(logging.ERROR)
+    logging.basicConfig(level=logging.INFO)
+    __app.logger.addHandler(logging.handlers.SysLogHandler(address="/dev/log"))  # Address for journald
+
+    @__app.before_request
+    def beforeRequest():
+        app_ctx.start_time = time.perf_counter()
+        app_ctx.start_timestamp = kutils.dates.currentTimestamp()
+
+    @__app.after_request
+    def logging_after(response):
+        # Get total time in milliseconds
+        total_time = round(time.perf_counter() - app_ctx.start_time, 4)
+        # Log the time taken for the endpoint 
+
+        current_app.logger.info('[%s %s %s %d] %s', request.method, app_ctx.start_timestamp, total_time, response.status_code, request.path)
+        
+        return response
+
 
 __init()
 
@@ -238,11 +260,13 @@ def endpoint(
 
             signature = inspect.signature(func)
             typeHints = func.__annotations__
-            parameters = signature.parameters
+            # parameters = signature.parameters
 
-            # print("parameters==>", parameters)
+            headers_type = typeHints.get("headers")
+            if headers_type and not (headers_type is dict):
+                raise TypeError("arg::headers type must be 'dict'")
 
-            if not handler.__doc__:
+            if not handler.__doc__ and not (handler.__doc__.strip()):
                 raise ValueError(
                     f"handler function {func.__name__} has no docString!")
 
@@ -265,6 +289,9 @@ def endpoint(
                         f"function `{handler.__name__}` should take either positional-only or keyword-only parameters")
 
                 if value.kind == inspect.Parameter.POSITIONAL_ONLY:
+                    if key == "headers":
+                        raise ValueError(f"arg: {key}, should ony be passed as keyword_only argument!")
+                    
                     if value.default is not inspect.Parameter.empty:
                         if not (resp := validateWithResponse(value.default, typeHints[key])):
                             raise ValueError(f'arg `{key}` default value: {resp.log}')
@@ -273,8 +300,12 @@ def endpoint(
                         args.append((key,))
                 elif value.kind == inspect.Parameter.KEYWORD_ONLY:
                     if value.default is not inspect.Parameter.empty:
+                        if key == "headers":
+                            raise ValueError(f'arg `{key}` should have no default value')
+                        
                         if not (resp := validateWithResponse(value.default, typeHints[key])):
                             raise ValueError(f'arg `{key}` default value: {resp.log}')
+                        
                         kwargs.append((key, value.default))
                     else:
                         kwargs.append((key,))
@@ -287,6 +318,10 @@ def endpoint(
                 if not hint:
                     raise TypeError(f"parameter {key} has no type hint")
 
+            # print(typeHints)
+            if "headers" in typeHints and "headers" in _WHITE_LISTED_PARAMS:
+                del typeHints["headers"]
+
             validationStructure = copy.deepcopy(typeHints)
             del validationStructure["return"]
 
@@ -308,7 +343,6 @@ def endpoint(
                 return resp
 
             payload = resp.data
-            # print("pyload====>", payload)
                 
             # Handle text payloads differently
             if isinstance(payload, (str, bytes)):
@@ -317,7 +351,6 @@ def endpoint(
                 raise BadRequest("Text input requires exactly one positional parameter")
 
             nonlocal validationStructure
-
             _args = []
             _kwargs = {}
 
@@ -334,10 +367,15 @@ def endpoint(
 
             for item in kwargs:
                 kwarg = item[0]
+                _headers_present = True if kwarg == "headers" else False  
 
                 if kwarg in payload:
                     _kwargs[kwarg] = payload[kwarg]
                 else:
+                    if _headers_present and kwarg == "headers":
+                            _kwargs[kwarg] = dict(request.headers)
+                            continue
+                    
                     if len(item) == 2:
                         default = item[1]
                         _kwargs[kwarg] = default
@@ -785,8 +823,28 @@ def _convert_single_type(value:Any, target_type:type)->Any:
     except (ValueError, TypeError) as e:
         raise ValueError(f"Cannot convert {value} to {target_type.__name__}: {str(e)}")
 
+@enforceRequirements
+def parse_headers(headers_str: str, /) -> dict:
+    """Parses a raw HTTP headers string into a dictionary.
+    
+    Args:
+        headers_str: Raw headers string (
+            e.g., "Content-Type: application/json\nAuthorization: Bearer token"
+        )
+    
+    Returns:
+        Dictionary with header names as keys and header values as values.
+    """
+    headers = {}
+    
+    for line in headers_str.strip().splitlines():
+        if ':' in line:
+            key, value = line.split(':', 1)
+            headers[key.strip()] = value.strip()
+    
+    return headers
 
 # startServer()
 if __name__ == "__main__":
     # print('======> app:', getAppInstance())
-    startServer()
+    startServer()

kisa_utils/structures/utils.py

@@ -1,6 +1,6 @@
 import inspect
 import typing
-from typing import Any, Callable
+from typing import Any, Callable, get_origin
 from types import UnionType
 from kisa_utils.response import Response
 
@@ -30,13 +30,23 @@ class Value:
             raise TypeError(f'validator should take only 1 argument (not counting `self` for methods)')
         
         reply = validator(
-            valueType() if type(valueType)==type(type) else list(typing.get_args(valueType))[0]()
+            valueType() if type(valueType)==type(type) \
+            else (
+                (
+                    _:=list(typing.get_args(valueType))[0]
+                ) 
+                and (
+                    get_origin(_) or _
+                )
+            )()
         )
 
         if not isinstance(reply, Response):
             raise TypeError(f'`validator` must return kutils.response.Response object')
 
-        self._valueType = valueType
+        typesTuple = valueType
+
+        self._valueType = typesTuple
         self._validator = validator
     
     def validate(self, valueInstance:Any, /) -> Response:
@@ -47,8 +57,9 @@ class Value:
 
     @property
     def __name__(self) -> str:
+        print(self._valueType)
         if not isinstance(self._valueType, UnionType):
-            _type = self._valueType.__name__
+            _type = (get_origin(self._valueType) or self._valueType).__name__
         else:
             types = self._valueType.__args__
             _type = '|'.join(_.__name__ for _ in types)

kisa_utils/structures/validator.py

@@ -3,7 +3,7 @@ this modules handle data structure validation to ensure that
 data is passed in expected formats/structures
 '''
 
-from typing import Any, get_args
+from typing import Any, get_args, get_origin
 from types import UnionType
 from kisa_utils.structures.utils import Value
 from kisa_utils.response import Response, Ok, Error
@@ -20,18 +20,23 @@ def validate(instance:Any, structure:Any, path:str='$') -> dict:
     
     result = {'status':False, 'log':''}
 
+    print(instance, structure, end=' => ')
+    if not isinstance(structure, UnionType) and get_origin(structure):
+        structure = get_origin(structure)
+    print(instance, structure)
+
     # union types such as int|float...
     if isinstance(structure, UnionType):
-        if not isinstance(instance, get_args(structure)):
-            expectedTypes = [str(_).split("'")[1] for _ in get_args(structure)]
+        if not isinstance(instance, tuple([get_origin(t) or t for t in get_args(structure)])):
+            expectedTypes = [str(_).split("'")[1] for _ in tuple([(get_args(t) or t) for t in get_args(structure)])]
             result['log'] = f'E06: types not similar:: {path}, expected one of {"|".join(expectedTypes)} but got {str(type(instance))[7:-1]}'
             return result
 
     # when the structure is a block type/class eg dict,list,tuple,etc
-    elif type(structure)==type(type) or isinstance(structure, Value):
-        _structure = structure._valueType if isinstance(structure, Value) else structure
+    elif type(structure)==type(type) or isinstance(structure, Value) or get_args(type):
+        _structure = structure._valueType if isinstance(structure, Value) else (get_args(structure) or structure)
 
-        if instance!=_structure and not isinstance(instance, _structure):
+        if instance != _structure and not isinstance(instance, _structure):
             result['log'] = f'E01: types not similar:: {path}, expected {str(_structure)[7:-1] if type(structure)==type(type) else structure.__name__} but got {str(type(instance))[7:-1]}'
             return result
 

{kisa_utils-0.36.2.dist-info → kisa_utils-0.36.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kisa-utils
-Version: 0.36.2
+Version: 0.36.4
 Summary: Utility functions and modules for KISA Developers
 Author: Tom Bukenya
 Author-email: glayn2bukman@gmail.com

{kisa_utils-0.36.2.dist-info → kisa_utils-0.36.4.dist-info}/RECORD

@@ -7,7 +7,7 @@ kisa_utils/db.py,sha256=qMOPfBHz9qJIKUwGvSk32EyyhvEFqOpDv0MX4QseXl0,40788
 kisa_utils/encryption.py,sha256=KwSUtjZj6m2JqEeeg0GW3bx93PCpEwJlcBzLZrnReyE,3522
 kisa_utils/enqueue.py,sha256=RbImgoPNFFCQHT1ow9zJEM-tHwWE1bNnHznJqEVXL9k,11290
 kisa_utils/figures.py,sha256=ossQHBR7T9rOV1yhQJLDbwrY23xf0RIGOmjcFH7P0ss,1860
-kisa_utils/functionUtils.py,sha256=dokWq3OlRplWBZWUdQ5Ev9jKKv3VXRSfBHxvJHP6ylk,5412
+kisa_utils/functionUtils.py,sha256=OPP9by-bpc7DssUFBpNNb0fPrUYxCnji4VlmxswHOrc,5718
 kisa_utils/log.py,sha256=EKBAVvDpY_hgALDCC6i-ARdqQzZwxBxxeHR4NsYgs9U,2120
 kisa_utils/queues.py,sha256=D0bCtI95VEg-xLuzf-Wp0Pfjc5hoEwlmzEJHuokx-i0,5418
 kisa_utils/remote.py,sha256=2EMG2kJudCYqpNPsACe3riQCqTsg-MzviVSZPbjCtxk,1793
@@ -19,11 +19,11 @@ kisa_utils/token.py,sha256=ReCIBsq95RMYCrDCyHgU1y_Eq-xp_PBpZiHxwsY6Fj4,8015
 kisa_utils/permissions/__config__.py,sha256=i3ELkOydDnjKx2ozQTxLZdZ8DXSeUncnl2kRxANjFmM,613
 kisa_utils/permissions/__init__.py,sha256=k7WbNlE8i9Vyf_SdbXbTh8D3gt4obDe3f8rONVVmNH4,36291
 kisa_utils/servers/__init__.py,sha256=lPqDyGTrFo0qwPZ2WA9Xtcpc5D8AIU4huqgFx1iZf68,19
-kisa_utils/servers/flask.py,sha256=0ZepldfHCQ403L_bWuWhXSTHEmiPTxLAhAKYniS-tKY,27952
+kisa_utils/servers/flask.py,sha256=niD6Cv04cs6YVMXB7MVjOQ4__78UfLLia7qHdz2FgUs,30354
 kisa_utils/structures/__init__.py,sha256=JBU1j3A42jQ62ALKnsS1Hav9YXcYwjDw1wQJtohXPbU,83
-kisa_utils/structures/utils.py,sha256=doZnnrKT5qGWZIOhXqBnD7mBBc7r-lhwcfpRKcK95Is,2237
-kisa_utils/structures/validator.py,sha256=2cKaVuY6ia6-pt6o73A6L11qInDz_tygFZdsbZU-RbA,3328
-kisa_utils-0.36.2.dist-info/METADATA,sha256=VbYnHxGxowvIc6O_rRFpvaVQYhCpovoEc_-mTi9jAiA,477
-kisa_utils-0.36.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-kisa_utils-0.36.2.dist-info/top_level.txt,sha256=URxY4sRuqmirOxWtztpVmPoGQdksEMYO6hmYsEDGz2Y,75
-kisa_utils-0.36.2.dist-info/RECORD,,
+kisa_utils/structures/utils.py,sha256=svnzNyVL-wLBEgkovgrqDKvGM4wxYaQGuQ4fFDUR_mo,2515
+kisa_utils/structures/validator.py,sha256=MPPZHXAepBWlF1UFuh5sShkqTzlqANWRLTE42gPz3oA,3647
+kisa_utils-0.36.4.dist-info/METADATA,sha256=kSNW8__fbO_VuZjb5d-eN3WjLE9lr9rFUqijPoKmVKY,477
+kisa_utils-0.36.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+kisa_utils-0.36.4.dist-info/top_level.txt,sha256=URxY4sRuqmirOxWtztpVmPoGQdksEMYO6hmYsEDGz2Y,75
+kisa_utils-0.36.4.dist-info/RECORD,,