fix import

bclib/__init__.py

@@ -1 +1,29 @@
-__version__ = "3.34.2"
+__version__ = "3.35.0"
+
+import bclib.context
+
+from bclib.listener.message import Message
+from bclib.listener.message_type import MessageType
+from bclib.listener.http_listener.http_base_data_name import HttpBaseDataName
+from bclib.listener.http_listener.http_base_data_type import HttpBaseDataType
+
+from bclib.predicate import Predicate
+from bclib.utility import DictEx, HttpStatusCodes, HttpMimeTypes, ResponseTypes, HttpHeaders
+
+from bclib.db_manager import *
+
+# from bclib.context.client_source_context import ClientSourceContext
+# from bclib.context.client_source_member_context import ClientSourceMemberContext
+# from bclib.context.context import Context
+# from bclib.context.restful_context import RESTfulContext
+# from bclib.context.web_context import WebContext
+# from bclib.context.request_context import RequestContext
+# from bclib.context.rabbit_context import RabbitContext
+# from bclib.context.socket_context import SocketContext
+# from bclib.context.merge_type import MergeType
+# from bclib.context.server_source_context import ServerSourceContext
+# from bclib.context.server_source_member_context import ServerSourceMemberContext
+# from bclib.context.source_context import SourceContext
+# from bclib.context.source_member_context import SourceMemberContext
+# from bclib.context.context_factory import ContextFactory
+# from bclib.context.end_point_context import EndPointContext

bclib/cache/__init__.py

@@ -1,2 +0,0 @@
-from bclib.cache.manager import CacheManager
-from bclib.cache.factory import CacheFactory

bclib/cache/cache_item/function_cache_item.py

@@ -1,8 +1,9 @@
-from ..cache_item.base_cache_item import BaseCacheItem
 from typing import Callable
+from bclib.cache.cache_item.base_cache_item import BaseCacheItem
+
 
 class FunctionCacheItem(BaseCacheItem):
-    def __init__(self, data: "any", life_time:"int", function:"Callable") -> None:
+    def __init__(self, data: "any", life_time: "int", function: "Callable") -> None:
         super().__init__(data, life_time)
         self.__function = function
 
@@ -11,4 +12,4 @@ def get_data(self, *args, **kwargs) -> "any":
         if data is None:
             data = self.__function(*args, **kwargs)
             self._update_data(data)
-        return data
+        return data

bclib/cache/cache_item/scalar_cache_item.py

@@ -1,5 +1,6 @@
-from .base_cache_item import BaseCacheItem
+from bclib.cache.cache_item.base_cache_item import BaseCacheItem
+
 
 class ScalarCacheItem(BaseCacheItem):
     def __init__(self, data: "any", life_time: int) -> None:
-        super().__init__(data, life_time)
+        super().__init__(data, life_time)

bclib/cache/cache_manager.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from bclib.utility import DictEx
+from bclib.cache.cache_status import CacheStatus
+
+
+class CacheManager(ABC):
+    def __init__(self, options: "DictEx") -> None:
+        super().__init__()
+        self._options = options
+
+    @abstractmethod
+    def cache_decorator(self, key: "str" = None, life_time: "int" = 0): ...
+
+    @abstractmethod
+    def get_cache(self, key: "str") -> "list|any|None": ...
+
+    @abstractmethod
+    def add_or_update(self, key: "str", data: "any",
+                      life_time: "int" = 0) -> "CacheStatus": ...
+
+    @abstractmethod
+    def clean(self) -> "CacheStatus": ...
+
+    @abstractmethod
+    def reset(self, keys: "list[str]" = None) -> "CacheStatus": ...

bclib/cache/factory.py

@@ -1,16 +1,18 @@
-from ..cache.manager import CacheManager
+from cache.cache_manager import CacheManager
 from abc import ABC
 from bclib.utility import DictEx
-from ..cache.in_memory_cache_manager import InMemoryCacheManager
-from ..cache.no_cache import NoCacheManager
+from bclib.cache.in_memory_cache_manager import InMemoryCacheManager
+from bclib.cache.no_cache import NoCacheManager
+
 
 class CacheFactory(ABC):
     @staticmethod
-    def create(options:"DictEx"=None) -> "CacheManager":
-        cache_type = str(options.type) if options is not None and options.has("type") else None
+    def create(options: "DictEx" = None) -> "CacheManager":
+        cache_type = str(options.type) if options is not None and options.has(
+            "type") else None
         if cache_type is not None:
             if cache_type == "memory":
                 return InMemoryCacheManager(options)
             else:
                 raise ValueError(f"Unknown type for cache ('${cache_type}')")
-        return NoCacheManager(options)
+        return NoCacheManager(options)

bclib/cache/in_memory_cache_manager.py

@@ -1,23 +1,24 @@
 from bclib.cache.cache_status import CacheStatus
-from ..cache.signal_base_cache_manager import SignalBaseCacheManager
+from bclib.cache.signal_base_cache_manager import SignalBaseCacheManager
 from bclib.utility import DictEx
-from ..cache.cache_status import CacheStatus
+from bclib.cache.cache_status import CacheStatus
 from typing import Callable
-from ..cache.cache_item.base_cache_item import BaseCacheItem
-from ..cache.cache_item.function_cache_item import FunctionCacheItem
-from .cache_item.scalar_cache_item import ScalarCacheItem
-from ..cache.value_item.base_value_item import BaseValueItem
-from ..cache.value_item.array_value_item import ArrayValueItem
-from ..cache.value_item.scalar_value_item import ScalarValueItem
+from bclib.cache.cache_item.base_cache_item import BaseCacheItem
+from bclib.cache.cache_item.function_cache_item import FunctionCacheItem
+from bclib.cache.cache_item.scalar_cache_item import ScalarCacheItem
+from bclib.cache.value_item.base_value_item import BaseValueItem
+from bclib.cache.value_item.array_value_item import ArrayValueItem
+from bclib.cache.value_item.scalar_value_item import ScalarValueItem
 from functools import wraps
 
+
 class InMemoryCacheManager(SignalBaseCacheManager):
-    
+
     def __init__(self, options: DictEx) -> None:
         super().__init__(options)
-        self.__cache_dict:"dict[str, BaseValueItem]" = dict()
+        self.__cache_dict: "dict[str, BaseValueItem]" = dict()
 
-    def __add_or_update(self, key:"str", cache_item:"BaseCacheItem", value_item:"BaseValueItem") -> "CacheStatus":
+    def __add_or_update(self, key: "str", cache_item: "BaseCacheItem", value_item: "BaseValueItem") -> "CacheStatus":
         if key not in self.__cache_dict:
             self.__cache_dict[key] = value_item(cache_item)
             return CacheStatus.ADDED
@@ -29,7 +30,7 @@ def __add_or_update(self, key:"str", cache_item:"BaseCacheItem", value_item:"Bas
                 print(repr(ex))
                 return CacheStatus.ERROR
 
-    def cache_decorator(self, key:"str"=None, life_time:"int"=0) -> "Callable":
+    def cache_decorator(self, key: "str" = None, life_time: "int" = 0) -> "Callable":
         """
         Decorator that caches the result of a function for a specified key and life time.
 
@@ -51,12 +52,12 @@ def decorator(function):
 
             @wraps(function)
             def wrapper(*args, **kwargs):
-                function_cache:"FunctionCacheItem" = function.cache
+                function_cache: "FunctionCacheItem" = function.cache
                 return function_cache.get_data(*args, **kwargs)
             return wrapper
         return decorator
 
-    def reset(self, keys:"list[str]"=None) -> "CacheStatus":
+    def reset(self, keys: "list[str]" = None) -> "CacheStatus":
         """
         Resets the cache by removing all items or specified keys.
 
@@ -86,10 +87,10 @@ def clean(self) -> "CacheStatus":
         self.__cache_dict = cleaned_cache_dict
         return CacheStatus.CLEANED
 
-    def get_cache(self, key:"str") -> "list|any|None":
+    def get_cache(self, key: "str") -> "list|any|None":
         return self.__cache_dict[key].get_item() if key in self.__cache_dict else None
-    
-    def add_or_update(self, key: str, data: "any", life_time:"int"= 0) -> "CacheStatus":
+
+    def add_or_update(self, key: str, data: "any", life_time: "int" = 0) -> "CacheStatus":
         """
         Add or update an item in the cache.
         Args:

bclib/cache/no_cache.py

@@ -1,5 +1,5 @@
-from ..cache.manager import CacheManager
-from ..cache.cache_status import CacheStatus
+from cache.cache_manager import CacheManager
+from bclib.cache.cache_status import CacheStatus
 
 
 class NoCacheManager(CacheManager):

bclib/cache/signal_base_cache_manager.py

@@ -1,39 +1,46 @@
-from ..cache.manager import CacheManager
+from cache.cache_manager import CacheManager
 from bclib.utility import DictEx
-from ..cache.signaler.factory import SignalerFactory
+from bclib.cache.signaler.factory import SignalerFactory
 import asyncio
 
+
 class SignalBaseCacheManager(CacheManager):
-    DEFAULT_CLEAN_INTERVAL = 43200 #Seconds => 12 Hours; 0 for indefinitely
-    DEFAULT_RESET_INTERVAL = 86400 #Seconds => 24 Hours; 0 for indefinitely
+    DEFAULT_CLEAN_INTERVAL = 43200  # Seconds => 12 Hours; 0 for indefinitely
+    DEFAULT_RESET_INTERVAL = 86400  # Seconds => 24 Hours; 0 for indefinitely
 
     def __init__(self, options: "DictEx") -> None:
         super().__init__(options)
-        self.__clean_interval = int(self._options.clean_interval) if self._options.has("clean_interval") else SignalBaseCacheManager.DEFAULT_CLEAN_INTERVAL
+        self.__clean_interval = int(self._options.clean_interval) if self._options.has(
+            "clean_interval") else SignalBaseCacheManager.DEFAULT_CLEAN_INTERVAL
         if self.__clean_interval < 0:
             raise ValueError("Invalid input for clean_interval!")
-        self.__reset_interval = int(self._options.reset_interval) if self._options.has("reset_interval") else SignalBaseCacheManager.DEFAULT_RESET_INTERVAL
+        self.__reset_interval = int(self._options.reset_interval) if self._options.has(
+            "reset_interval") else SignalBaseCacheManager.DEFAULT_RESET_INTERVAL
         if self.__reset_interval < 0:
             raise ValueError("Invalid input for reset_interval!")
-        signaler_options = self._options.signaler if self._options.has("signaler") else None
-        self._reset_signaler = SignalerFactory.create(self.reset, signaler_options)
+        signaler_options = self._options.signaler if self._options.has(
+            "signaler") else None
+        self._reset_signaler = SignalerFactory.create(
+            self.reset, signaler_options)
         if self.__reset_interval > 0 or self.__clean_interval > 0:
             loop = asyncio.get_event_loop()
             if self.__reset_interval > 0:
                 loop.create_task(self.__reset_async(self.__reset_interval))
             if self.__clean_interval > 0:
                 loop.create_task(self.__clean_async(self.__clean_interval))
-    
-    async def __reset_async(self, interval:"int"):
+
+    async def __reset_async(self, interval: "int"):
         try:
             while True:
                 await asyncio.sleep(interval)
                 self.reset()
-        except: ...
+        except:
+            ...
 
-    async def __clean_async(self, interval:"int"):
+    async def __clean_async(self, interval: "int"):
         try:
             while True:
                 await asyncio.sleep(interval)
                 self.clean()
-        except: ...
+        except:
+            ...

bclib/cache/signaler/factory.py

@@ -1,13 +1,14 @@
 from abc import ABC
-from ..signaler.base_signaler import BaseSignaler
-from bclib.utility import DictEx
-from ..signaler.no_signaler import NoSignaler
-from ..signaler.rabbit_signaler import RabbitSignaller
 from typing import Callable
+from bclib.cache.signaler.base_signaler import BaseSignaler
+from bclib.cache.signaler.no_signaler import NoSignaler
+from bclib.cache.signaler.rabbit_signaler import RabbitSignaller
+from bclib.utility import DictEx
+
 
 class SignalerFactory(ABC):
     @staticmethod
-    def create(reset_cache_callback:"Callable", signaler_options:"DictEx"=None) -> "BaseSignaler":
+    def create(reset_cache_callback: "Callable", signaler_options: "DictEx" = None) -> "BaseSignaler":
         """        
         This is a factory function for create signaler
 
@@ -26,5 +27,6 @@ def create(reset_cache_callback:"Callable", signaler_options:"DictEx"=None) -> "
             if signaler_type == "rabbit":
                 return RabbitSignaller(reset_cache_callback, signaler_options)
             else:
-                raise ValueError(f"Unknown type for signaler ('${signaler_type}')")
-        return NoSignaler()
+                raise ValueError(
+                    f"Unknown type for signaler ('${signaler_type}')")
+        return NoSignaler()

bclib/cache/signaler/no_signaler.py

@@ -1,7 +1,8 @@
-from ..signaler.base_signaler import BaseSignaler
+from bclib.cache.signaler.base_signaler import BaseSignaler
+
 
 class NoSignaler(BaseSignaler):
     """Implement no signaller for cache"""
 
     def __init__(self) -> None:
-        super().__init__(None, None)
+        super().__init__(None, None)

bclib/cache/signaler/rabbit_signaler.py

@@ -1,12 +1,14 @@
 from typing import Callable
 import json
 import asyncio
-from ..signaler.base_signaler import BaseSignaler
+from bclib.cache.signaler.base_signaler import BaseSignaler
 from bclib.utility import DictEx
 
+
 class RabbitSignaller(BaseSignaler):
     """Implement rabbit-mq signaler"""
-    def __init__(self, reset_cache_callback:"Callable", options:"DictEx") -> None:
+
+    def __init__(self, reset_cache_callback: "Callable", options: "DictEx") -> None:
         super().__init__(reset_cache_callback, options)
         import pika
         try:

bclib/cache/value_item/array_value_item.py

@@ -1,6 +1,6 @@
 from bclib.cache.cache_item.base_cache_item import BaseCacheItem
-from ..value_item.base_value_item import BaseValueItem
-from ..cache_item.function_cache_item import FunctionCacheItem
+from bclib.cache.value_item.base_value_item import BaseValueItem
+
 
 class ArrayValueItem(BaseValueItem):
 

bclib/cache/value_item/base_value_item.py

@@ -1,18 +1,19 @@
 from abc import ABC, abstractmethod
-from ..cache_item.base_cache_item import BaseCacheItem
+from bclib.cache.cache_item.base_cache_item import BaseCacheItem
+
 
 class BaseValueItem(ABC):
-    def __init__(self, cache_item:"BaseCacheItem") -> None:
+    def __init__(self, cache_item: "BaseCacheItem") -> None:
         super().__init__()
-        self._item:"list[BaseCacheItem]|BaseCacheItem" = None
+        self._item: "list[BaseCacheItem]|BaseCacheItem" = None
         self._apply_item(cache_item)
-    
+
     @abstractmethod
-    def _apply_item(self, cache_item:"BaseCacheItem"): ...
+    def _apply_item(self, cache_item: "BaseCacheItem"): ...
 
     def add_or_update_item(self, cache_item: "BaseCacheItem"):
         self._apply_item(cache_item)
-    
+
     def get_item(self) -> "list|any|None":
         if self._item is not None:
             if isinstance(self._item, list):
@@ -27,7 +28,6 @@ def get_item(self) -> "list|any|None":
         else:
             ret_val = None
         return ret_val
-    
+
     def reset(self):
         self._item = None
-

bclib/cache/value_item/scalar_value_item.py

@@ -1,7 +1,8 @@
 from bclib.cache.cache_item.base_cache_item import BaseCacheItem
-from ..value_item.base_value_item import BaseValueItem
+from bclib.cache.value_item.base_value_item import BaseValueItem
+
 
 class ScalarValueItem(BaseValueItem):
-    
+
     def _apply_item(self, cache_item: "BaseCacheItem") -> "BaseCacheItem":
         self._item = cache_item