cndi 0.1.0__py3-none-any.whl

cndi/__init__.py

@@ -0,0 +1,4 @@
+import logging
+
+logging.basicConfig(format=f'%(asctime)s - %(name)s -  %(levelname)s - %(message)s', level=logging.INFO)
+BASE_NAME = "RCN"

cndi/annotations/__init__.py

@@ -0,0 +1,416 @@
+"""
+This module provides functionality for managing components and beans in the application.
+
+It includes functionality for importing modules, normalizing module and class names, and managing various stores for beans, components, profiles, conditional rendering, and overrides.
+
+Variables:
+    validatedBeans: A list of validated beans.
+    beans: A list of beans.
+    autowires: A list of autowires.
+    components: A list of components.
+    beanStore: A dictionary storing beans.
+    componentStore: A dictionary storing components.
+    profilesStores: A dictionary storing profiles.
+    conditionalRender: A dictionary storing conditional rendering settings.
+    overrideStore: A dictionary storing overrides.
+
+Functions:
+    importModuleName: Imports a module given its full name.
+    normaliseModuleAndClassName: Normalizes a module and class name.
+"""
+
+import logging
+import os
+import types
+from typing import Callable, Any
+
+from cndi.annotations.component import ComponentClass
+from cndi.env import RCN_ACTIVE_PROFILE
+from cndi.exception import BeanNotFoundException
+
+logger = logging.getLogger("cndi.annotations")
+
+class SingletonContext:
+    """Singleton context manager for storing beans, components, and related data."""
+    _instance = None
+    _frozen = False
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(SingletonContext, cls).__new__(cls)
+            cls._instance.validatedBeans = []
+            cls._instance.beans = []
+            cls._instance.autowires = []
+            cls._instance.components = []
+            cls._instance.beanStore = {}
+            cls._instance.componentStore = {}
+            cls._instance.profilesStores = {}
+            cls._instance.conditionalRender = {}
+            cls._instance.overrideStore = {}
+        return cls._instance
+
+    def freeze(self):
+        """Freeze the context to make all stored values immutable."""
+        self.validatedBeans = tuple(self.validatedBeans)
+        self.beans = tuple(self.beans)
+        self.autowires = tuple(self.autowires)
+        self.components = tuple(self.components)
+        self.beanStore = types.MappingProxyType(self.beanStore)
+        self.componentStore = types.MappingProxyType(self.componentStore)
+        self.profilesStores = types.MappingProxyType(self.profilesStores)
+        self.conditionalRender = types.MappingProxyType(self.conditionalRender)
+        self.overrideStore = types.MappingProxyType(self.overrideStore)
+        SingletonContext._frozen = True
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if SingletonContext._frozen:
+            raise AttributeError(f"Cannot modify frozen context attribute: {name}")
+        super().__setattr__(name, value)
+
+context = SingletonContext()
+
+from functools import wraps
+import importlib
+import copy
+
+
+def importModuleName(fullname):
+    modules = fullname.split('.')
+    module = importlib.import_module(modules[-1], package='.'.join(modules[:-1]))
+    return module
+
+
+def normaliseModuleAndClassName(name):
+    nameList: list = name.split(".")
+    if "__init__" in nameList:
+        nameList.remove("__init__")
+    return '.'.join(nameList)
+
+
+def getBeanObject(objectType):
+    """
+    Retrieves a bean object from the bean storage.
+
+    This function queries the bean storage for a bean of the specified type. If the bean is found, it returns a new instance of the bean if the 'newInstance' attribute of the bean is True, otherwise it returns the existing instance.
+
+    Args:
+        objectType: The type of the bean to retrieve.
+
+    Returns:
+        An instance of the bean of the specified type.
+    """
+    if isinstance(objectType, type):
+        objectType = normaliseModuleAndClassName('.'.join([objectType.__module__, objectType.__name__]))
+    bean = queryBeanStorage(objectType)
+    objectInstance = bean['objectInstance']
+    return copy.deepcopy(objectInstance) if bean['newInstance'] else objectInstance
+
+
+def queryBeanStorage(fullname):
+    objectType = normaliseModuleAndClassName(fullname)
+    bean = context.beanStore[objectType]
+    return bean
+
+
+class AutowiredClass:
+    def __init__(self, required, func, kwargs: dict):
+        self.fullname = '.'.join([func.__qualname__])
+        self.className = normaliseModuleAndClassName('.'.join(func.__qualname__.split(".")[:-1]))
+        self.func = func
+        self.kwargs = kwargs
+        self.required = required
+        self.context = SingletonContext()
+
+    def dependencyInject(self):
+        dependencies = self.calculateDependencies()
+        dependencyNotFound = list()
+        for dependency in dependencies:
+            if dependency not in self.context.beanStore:
+                dependencyNotFound.append(dependency)
+
+        if len(dependencyNotFound) > 0:
+            logger.warning(f"Skipping {self.fullname}")
+            assert not self.required, "Could not initialize " + self.fullname + " with beans " + str(
+                dependencyNotFound)
+
+        kwargs = self.kwargs
+        args = dict()
+        for (key, value) in kwargs.items():
+            fullName = normaliseModuleAndClassName('.'.join([value.__module__, value.__name__]))
+            if fullName in self.context.beanStore:
+                args[key] = getBeanObject(fullName)
+
+        if self.className in self.context.beanStore:
+            self.func(self.context.beanStore[self.className], **args)
+        else:
+            logger.debug(f"{self.className} {self.fullname}")
+            self.func(**args)
+
+    def calculateDependencies(self):
+        return list(
+            map(lambda dependency: normaliseModuleAndClassName('.'.join([dependency.__module__, dependency.__name__])),
+                self.kwargs.values()))
+
+
+def OverrideBeanType(type: object):
+    """
+    OverrideBeanType is used to override the current annotated @Component class to be injected as some other object
+
+    :param type: Class type to override while performing Dependency Injection
+    :return: function wrapper
+    """
+
+    def inner_function(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        fullname = '.'.join([wrapper.__module__, wrapper.__name__])
+
+        context.overrideStore[fullname] = {
+            "func": wrapper,
+            "overrideType": type
+        }
+        return wrapper
+
+    return inner_function
+
+
+def queryOverideBeanStore(fullname):
+    if fullname in context.overrideStore:
+        return context.overrideStore[fullname]
+    else:
+        return None
+
+
+def Component(func: object):
+    """
+    A decorator that registers a class as a component.
+
+    When a class is decorated with @Component, the AppInitializer tries to automatically initialize the class. The class is registered with its full name, which is constructed from the module name and the class name.
+
+    Args:
+        func: The class to be registered as a component.
+
+    Returns:
+        The decorated class.
+    """
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    moduleName = wrapper.__module__[:-9] if wrapper.__module__.endswith(".__init__") else wrapper.__module__
+    componentFullName = '.'.join([moduleName, wrapper.__qualname__])
+    logger.debug(f"Registering Function name " + componentFullName)
+    duplicateComponents = list(filter(lambda component: component.fullname == componentFullName, context.components))
+    if duplicateComponents.__len__() > 0:
+        logger.debug(f"Duplicate Component found for: {duplicateComponents}")
+    else:
+        context.components.append(ComponentClass(**{
+            'fullname': componentFullName,
+            'func': wrapper,
+            'annotations': wrapper.__init__.__annotations__ if "__annotations__" in dir(wrapper.__init__) else {}
+        }))
+    return wrapper
+
+
+def validateBean(fullname):
+    """
+    Validates Beans before performing the dependency injection
+    :param fullname: bean class full classpath name
+    :return: Boolean type
+    """
+
+    profile = queryProfileData(fullname)
+    condition = queryContitionalRenderingStore(fullname)
+    if profile is None and condition is None:
+        return True
+    flag = True
+
+    if profile is not None:
+        profileNames = set(profile['profiles'])
+        environmentProfiles = set(map(lambda x: x.strip(), os.environ[RCN_ACTIVE_PROFILE].split(",")))
+        intersectionProfiles = profileNames.intersection(environmentProfiles)
+
+        flag &= intersectionProfiles.__len__() >= 1
+
+    if condition is not None:
+        callback = condition['callback']
+        callbackValue = callback(condition['func'])
+        flag &= bool(callbackValue)
+
+    if flag is False:
+        logger.debug("Validation Failed for Bean " + fullname)
+
+    return flag
+
+
+def Bean(newInstance=False):
+    """
+
+    :param newInstance:
+    :return:
+    """
+
+    def inner_function(func):
+        annotations = func.__annotations__
+        returnType = annotations['return']
+        del annotations['return']
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        fullname = '.'.join([returnType.__module__, returnType.__name__])
+        annotations = dict(
+            map(lambda key: (key, '.'.join([annotations[key].__module__, annotations[key].__qualname__])), annotations))
+
+        if validateBean(fullname):
+            context.beans.append({
+                'name': fullname,
+                'newInstance': newInstance,
+                'object': wrapper,
+                'fullname': wrapper.__qualname__,
+                'kwargs': annotations,
+                'index': len(context.beans)
+            })
+
+            return wrapper
+        else:
+            return None
+
+    return inner_function
+
+
+def ConditionalRendering(callback=lambda method: True, overrideFullName = None):
+    """
+    A decorator that conditionally renders a class based on a callback function.
+
+    This decorator checks the return value of the provided callback function. If the callback returns True, the class is rendered. If the callback returns False, the class is not rendered.
+
+    Args:
+        callback: A function that determines whether the class should be rendered. This function should take no arguments and return a boolean.
+
+    Returns:
+        The decorated class, if the callback returns True. None, if the callback returns False.
+    """
+
+    def inner_function(func: object):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        fullname = ".".join([wrapper.__module__, wrapper.__qualname__]) if overrideFullName is None else overrideFullName
+
+        context.conditionalRender[fullname] = {
+            "func": wrapper,
+            "callback": callback
+        }
+
+        return wrapper
+
+    return inner_function
+
+
+def queryContitionalRenderingStore(fullname):
+    if fullname in context.conditionalRender:
+        return context.conditionalRender[fullname]
+    else:
+        return None
+
+def constructKeyWordArguments(annotations, required=True):
+    kwargs = dict()
+    for key, classObject in annotations.items():
+        beanName = f"{classObject.__module__}.{classObject.__name__}"
+        if beanName in context.beanStore:
+            kwargs[key] = getBeanObject(beanName)
+        elif required:
+            raise BeanNotFoundException(f"Following Bean failed to load in SingletonContext: "+beanName)
+        else:
+            logger.warn(f"Bean not found {beanName} and required is set to false")
+    return kwargs
+
+def Profile(profiles=["default"]):
+    """
+
+    :param profiles:
+    :return:
+    """
+
+    def inner_function(func: Callable):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        fullname = ".".join([wrapper.__module__, wrapper.__qualname__])
+        context.profilesStores[fullname] = {
+            "func": wrapper,
+            "profiles": profiles
+        }
+
+        return wrapper
+
+    return inner_function
+
+
+def queryProfileData(fullname):
+    if fullname in context.profilesStores:
+        return context.profilesStores.get(fullname)
+    else:
+        return None
+
+
+def Autowired(required=True):
+    """
+    
+    :param required:
+    :return:
+    """
+
+    def inner_function(func: object):
+        annotations = func.__annotations__
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        context.autowires.append(AutowiredClass(required=required, **{
+            'kwargs': annotations,
+            'func': wrapper
+        }))
+
+        return wrapper
+
+    return inner_function
+
+def getBean(beans, name):
+    return list(filter(lambda x: x['name'] == name, beans))[0]
+
+
+def workOrder(beans):
+    allBeanNames = list(map(lambda bean: bean['name'], beans))
+    beanQueue = list(filter(lambda bean: len(bean['kwargs']) == 0, beans))
+    beanIndexes = list(map(lambda bean: bean['index'], beanQueue))
+
+    beanDependents = list(filter(lambda bean: bean['index'] not in beanIndexes, beans))
+    beanQueueNames = list(map(lambda bean: bean['name'], beanQueue))
+
+    for i in range(len(beanQueue)):
+        beanQueue[i]['index'] = i
+
+    for dependents in beanDependents:
+        args = list(dependents['kwargs'].values())
+        flag = True
+        for argClassName in args:
+            if (argClassName not in beanQueueNames and argClassName in allBeanNames) or argClassName in beanQueueNames:
+                flag = flag and True
+                dependents['index'] = getBean(beans, argClassName)['index'] + max(beanIndexes)
+            else:
+                flag = False
+
+        if flag:
+            beanQueue.append(dependents)
+            beanQueueNames.append(dependents['name'])
+
+    assert len(beanQueue) == len(beans), "Somebeans were not initialized properly"
+    return list(sorted(beanQueue, key=lambda x: x['index']))

cndi/annotations/component.py

@@ -0,0 +1,11 @@
+class ComponentClass:
+    def __init__(self, fullname, func, annotations):
+        self.fullname = fullname
+        self.func = func
+        self.annotations = annotations
+
+    def getInnerAutowiredClasses(self, autowires):
+        return list(filter(
+            lambda autowire: autowire.className == self.fullname,
+            autowires
+        ))

cndi/annotations/events.py

@@ -0,0 +1,79 @@
+import asyncio
+import dataclasses
+import logging
+from concurrent.futures.thread import ThreadPoolExecutor
+from functools import wraps
+from typing import Dict, Callable
+
+from cndi.annotations import Component, constructKeyWordArguments, ConditionalRendering
+from cndi.consts import RCN_EVENTS_ENABLE, RCN_EVENTS_NUM_THREADS
+from cndi.env import getContextEnvironment
+
+logger = logging.getLogger(__name__)
+
+class BuiltInEventsTypes:
+    ON_ENV_LOAD="on_env_load"
+    ON_CONTEXT_LOAD="on_context_load"
+
+@dataclasses.dataclass
+class Event(object):
+    def __init__(self, eventType,
+                 eventCallback, kwargs=None):
+        if kwargs is None:
+            kwargs = {}
+        self.eventType = eventType
+        self.eventCallback: Callable = eventCallback
+        self.kwargs = kwargs
+
+REGISTERED_EVENTS: Dict[str, dict[str, Event]] = dict()
+def register_event(event: Event, func_name: str):
+    if event.eventType not in REGISTERED_EVENTS:
+        REGISTERED_EVENTS[event.eventType] = dict()
+
+    REGISTERED_EVENTS[event.eventType][func_name] = event
+
+def OnEvent(event):
+    def inner_function(func):
+        annotations = func.__annotations__
+
+        func_name = '.'.join([func.__module__, func.__qualname__])
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if asyncio.iscoroutinefunction(func):
+                return asyncio.run(func(*args, **kwargs))
+            return func(*args, **kwargs)
+
+        register_event(Event(eventType=event, eventCallback=wrapper, kwargs=annotations), func_name)
+
+        return wrapper
+    return inner_function
+
+class EventNotFound(Exception):
+    def __init__(self, *args):
+        super().__init__( *args)
+
+@Component
+@ConditionalRendering(callback=lambda x: getContextEnvironment(RCN_EVENTS_ENABLE, defaultValue=False, castFunc=bool)
+                            and getContextEnvironment(RCN_EVENTS_NUM_THREADS, defaultValue=1, castFunc=int) > 0)
+class EventBus:
+    def __init__(self):
+        self._executor = ThreadPoolExecutor(max_workers=getContextEnvironment(RCN_EVENTS_NUM_THREADS, defaultValue=1, castFunc=int))
+
+    def publish(self, event_name: str, data=None) -> None:
+        if data is None:
+            data = {}
+        if event_name in REGISTERED_EVENTS:
+            for func_name, event  in REGISTERED_EVENTS[event_name].items():
+                kwargs = {
+                    **constructKeyWordArguments(event.kwargs, required=False),
+                    **data
+                }
+                kwargs = dict(map(lambda x: [x, kwargs[x]], set(event.kwargs.keys()).intersection(kwargs.keys())))
+                self._executor.submit(event.eventCallback, **kwargs)
+        else:
+            logger.warning(f"{event_name} event not found, please check the decorators")
+
+    def subscribe(self, event_name: str, event: Event) -> None:
+        if event_name not in REGISTERED_EVENTS:
+            REGISTERED_EVENTS[event_name] = dict()
+        REGISTERED_EVENTS[event_name][event.eventType] = event

cndi/annotations/threads.py

@@ -0,0 +1,35 @@
+import logging
+from threading import Thread
+from typing import List
+
+from cndi.annotations import Component, ConditionalRendering
+from cndi.consts import RCN_ENABLE_CONTEXT_THREADS
+from cndi.env import getContextEnvironment
+
+log = logging.getLogger(__name__)
+
+def isContextThreadEnable(dependent):
+    enabled = getContextEnvironment(RCN_ENABLE_CONTEXT_THREADS, defaultValue=False, castFunc=bool)
+    if not enabled:
+        log.warning(f"{dependent} Component depends on {__name__}.{ContextThreads.__name__}")
+        log.warning(f"SingletonContext Threads is disable in property please enable it by setting {RCN_ENABLE_CONTEXT_THREADS} to true")
+
+    return enabled
+
+@Component
+@ConditionalRendering(callback=lambda x: getContextEnvironment(RCN_ENABLE_CONTEXT_THREADS, defaultValue=False, castFunc=bool))
+class ContextThreads:
+    def __init__(self):
+        self.threads: List[Thread] = list()
+
+    def add_thread(self, thread):
+        self.threads.append(thread)
+
+    def clean_up(self):
+        exitedThread = []
+        for thread in self.threads:
+            if not thread.is_alive():
+                exitedThread.append(thread)
+
+        for exitThread in exitedThread:
+            self.threads.remove(exitThread)

cndi/autoconfiguration/configure.py

@@ -0,0 +1,11 @@
+from cndi.annotations import Component, ConditionalRendering
+from cndi.consts import RCN_AUTO_CONFIGURE_SECRETS_ENABLE
+from cndi.env import getContextEnvironment
+
+
+@Component
+@ConditionalRendering(callback=lambda x: getContextEnvironment(RCN_AUTO_CONFIGURE_SECRETS_ENABLE, defaultValue=False, castFunc=bool))
+class AutoConfigurationProviders:
+    _PROVIDERS = dict()
+    def __init__(self):
+        pass

cndi/binders/consts.py

@@ -0,0 +1 @@
+RCN_MESSAGE_BINDERS="rcn.binders.message"