wattleflow 0.0.0.3__py3-none-any.whl

wattleflow/core/__init__.py

@@ -0,0 +1,173 @@
+# Author: (wattleflow@outlook.com)
+# Copyright: (c) 2022-2024 WattleFlow
+# License: Apache 2 Licence
+
+from .framework import IWattleflow
+from .behavioral import (
+    IHandler,
+    ICommand,
+    IInvoker,
+    IExpression,
+    IIterator,
+    IAsyncIterator,
+    IAggregate,
+    IMediator,
+    IColleague,
+    IMemento,
+    IOriginator,
+    IObserver,
+    IObservable,
+    IState,
+    IStateContext,
+    IStrategy,
+    IStrategyContext,
+    ITemplate,
+    IVisitor,
+    IElement,
+)
+from .concurent import (
+    IFuture,
+    IPromise,
+    ICallback,
+    IObserverReactive,
+    IObservableReactive,
+    IEventLoop,
+    IPublisher,
+    ISubscriber,
+    IMessageQueue,
+    IThreadPool,
+    ICoroutine,
+    IMapper,
+    IReducer,
+    ISuperstep,
+    IBSPSystem,
+    IForkJoinTask,
+    IForkJoinPool,
+    IBarrier,
+    IDivideAndConquer,
+    IDataParallelTask,
+    IWorkStealingScheduler,
+    IWorker,
+    IStencil,
+    IGraphProcessing,
+    ISPMDProgram,
+)
+from .creational import (
+    IFactory,
+    IBuilder,
+    IProduct,
+    ICreator,
+    IPrototype,
+    ISingleton
+)
+from .structural import (
+    ITarget,
+    IAdaptee,
+    IAdapter,
+    IImplementor,
+    IAbstraction,
+    IComponent,
+    IComposite,
+    IDecorator,
+    IFacade,
+    IGraph,
+    IFlyweight,
+    IFlyweightFactory,
+    IProxy,
+)
+from .transactional import (
+    IActor,
+    ISystem,
+    IEventListener,
+    IEventSource,
+    IDataflowComponent,
+    IRepository,
+    IBlackboard,
+    IModule,
+    IPipeline,
+    IProcessor,
+    IQuery,
+    ISaga,
+    IUnitOfWork,
+)
+
+__all__ = [
+    "IWattleflow",
+    "IHandler",
+    "ICommand",
+    "IInvoker",
+    "IExpression",
+    "IIterator",
+    "IAsyncIterator",
+    "IAggregate",
+    "IMediator",
+    "IColleague",
+    "IMemento",
+    "IOriginator",
+    "IObserver",
+    "IObservable",
+    "IState",
+    "IStateContext",
+    "IStrategy",
+    "IStrategyContext",
+    "ITemplate",
+    "IVisitor",
+    "IElement",
+    "IFuture",
+    "IPromise",
+    "ICallback",
+    "IObserverReactive",
+    "IObservableReactive",
+    "IEventLoop",
+    "IPublisher",
+    "ISubscriber",
+    "IMessageQueue",
+    "IThreadPool",
+    "ICoroutine",
+    "IMapper",
+    "IReducer",
+    "ISuperstep",
+    "IBSPSystem",
+    "IForkJoinTask",
+    "IForkJoinPool",
+    "IBarrier",
+    "IDivideAndConquer",
+    "IDataParallelTask",
+    "IWorkStealingScheduler",
+    "IWorker",
+    "IStencil",
+    "IGraphProcessing",
+    "ISPMDProgram",
+    "IFactory",
+    "IBuilder",
+    "IProduct",
+    "ICreator",
+    "IPrototype",
+    "ISingleton",
+    "ITarget",
+    "IAdaptee",
+    "IAdapter",
+    "IImplementor",
+    "IAbstraction",
+    "IComponent",
+    "IComposite",
+    "IDecorator",
+    "IFacade",
+    "IGraph",
+    "IFlyweight",
+    "IFlyweightFactory",
+    "IProxy",
+    "IActor",
+    "ISystem",
+    "IEventListener",
+    "IEventSource",
+    "IDataflowComponent",
+    "IRepository",
+    "IBlackboard",
+    "IModule",
+    "IPipeline",
+    "IProcessor",
+    "IQuery",
+    "ISaga",
+    "IUnitOfWork",
+]

wattleflow/core/behavioral.py

@@ -0,0 +1,379 @@
+# Module Name: behavioural.py
+# Author: (wattleflow@outlook.com)
+# Copyright: (c) 2022-2024 WattleFlow
+# License: Apache 2 Licence
+# Description: This modul contains abstract design pattern interfaces.
+
+from abc import ABC, abstractmethod
+from .framework import IWattleflow
+from typing import (
+    Any,
+    AsyncIterator,
+    Generic,
+    Iterator,
+    Type,
+    TypeVar,
+)
+
+
+T = TypeVar("T")
+
+"""
+Behavioral Interfaces
+    Chain of Responsibility
+        IHandler
+    Command
+        ICommand
+    Interpreter
+        IExpression
+    Iterator
+        IIterator
+        IAggregate
+    Mediator
+        IMediator
+    Memento
+        IMemento
+        IOriginator
+    Observer
+        IObserver
+        IObservable
+    State
+        IState
+        IStateContext
+    Strategy
+        IStrategy
+        IStrategyContext
+    Template Method
+        ITemplate
+    Visitor
+        IVisitor
+        IElement
+"""
+
+
+# Behavioural interfaces
+# Chain of responsiblity interfaces (IHandler, ICommand, IInvoker)
+# IHandler
+class IHandler(IWattleflow, ABC):
+    """
+    IHandler - Chain of responsibilty abstract interface.
+
+    Interface:
+        set_next(self, handler)
+        handle(self, request)
+    """
+
+    @abstractmethod
+    def set_next(self, handler: "IHandler"):
+        pass
+
+    @abstractmethod
+    def handle(self, request):
+        pass
+
+
+class ICommand(IWattleflow, ABC):
+    """
+    ICommand - Chain of responsibilty abstract interface.
+
+    Interface:
+        execute(self, *args, **kwargs)
+    """
+
+    @abstractmethod
+    def execute(self, *args, **kwargs) -> Any:
+        pass
+
+
+class IInvoker(IWattleflow, ABC):
+    """
+    IInvoker - Chain of responsibilty abstract interface.
+
+    Interface:
+        set_command(self, command)
+        invoke(self)
+    """
+
+    @abstractmethod
+    def set_command(self, command: ICommand):
+        pass
+
+    @abstractmethod
+    def invoke(self) -> Any:
+        pass
+
+
+# Interpreter Interface
+class IExpression(IWattleflow, ABC):
+    """
+    IExpression - abstract interface.
+
+    Interface:
+        interpret(self)
+    """
+
+    @abstractmethod
+    def interpret(self, context):
+        pass
+
+
+# Iterator interfaces (IIterator, IAsyncIterator)
+# IIterator
+class IIterator(Generic[T], ABC):
+    """
+    IIterator - Interface for synchronous iterators.
+
+    Methods:
+        - __iter__() -> Iterator[T]: Enables iteration using 'for'.
+        - __next__() -> T: Retrieves next item synchronously.
+        - create_iterator() -> Iterator[T]: Returns an iterator instance.
+    """
+
+    _cycle: int = 0
+    _iterator: Iterator[T] = None  # Sinkroni iterator
+
+    def __iter__(self) -> Iterator[T]:
+        return self
+
+    def __next__(self) -> T:
+        """Returns the item synchronously in iteration | StopIteration."""
+        try:
+            current = next(self._iterator)
+            self._cycle += 1
+            return current
+        except StopIteration:
+            raise
+
+    @abstractmethod
+    def create_iterator(self) -> Iterator[T]:
+        """
+        Must implement: a new instance of the iterator.
+        """
+        pass
+
+
+# IAsyncIterator
+class IAsyncIterator(Generic[T], ABC):
+    """
+    IAsyncIterator - Interface for asynchronous iterators.
+    """
+
+    _cycle: int = 0
+    _iterator: AsyncIterator[T] = None
+
+    def __aiter__(self) -> AsyncIterator[T]:
+        return self
+
+    async def __anext__(self) -> T:
+        """Returns the item asynchronously or raises StopAsyncIteration."""
+        try:
+            current = await anext(self._iterator)
+            self._cycle += 1
+            return current
+        except StopAsyncIteration:
+            raise
+
+    @abstractmethod
+    async def create_iterator(self) -> AsyncIterator[T]:
+        """Must implement: a new instance of the async iterator."""
+        pass
+
+
+class IAggregate(IWattleflow, Type[IIterator], ABC):
+    """
+    IAggregate - abstract interface.
+
+    Interface:
+        create_iterator(self) -> IITerator
+    """
+
+    @abstractmethod
+    def create_iterator(self) -> IIterator:
+        pass
+
+
+# Mediator interfaces
+class IMediator(IWattleflow, ABC):
+    """
+    IMediator - abstract interface.
+
+    Interface:
+        notify(self, sender, event)
+    """
+
+    @abstractmethod
+    def notify(self, sender, event):
+        pass
+
+
+class IColleague(IWattleflow, ABC):
+    """
+    IColleage - abstract interface.
+
+    Interface:
+        set_mediator(self, mediator)
+        event_occurred(self, event)
+    """
+
+    @abstractmethod
+    def set_mediator(self, mediator):
+        pass
+
+    @abstractmethod
+    def event_occurred(self, event):
+        pass
+
+
+# Memento Interfaces (IMemento, IOriginator)
+# IMemento
+class IMemento(IWattleflow, ABC):
+    """
+    IMemento - abstract interface.
+
+    Interface:
+        get_state(self)
+    """
+
+    @abstractmethod
+    def get_state(self):
+        pass
+
+
+class IOriginator(IWattleflow, ABC):
+    """
+    IOriginator - abstract interface.
+
+    Interface:
+        save_state(self)
+        restore_state(self, memento)
+    """
+
+    @abstractmethod
+    def save_state(self):
+        pass
+
+    @abstractmethod
+    def restore_state(self, memento: IMemento):
+        pass
+
+
+# Observer interfaces
+# Reactive Programming Interfaces
+class IObserver(IWattleflow, ABC):
+    """
+    IObserver - Observer/Reactive Programming Interface desing pattern
+                abstract interface.
+
+    Interface:
+        subscribe(self,observer)
+    """
+
+    @abstractmethod
+    def update(self, *args, **kwargs):
+        pass
+
+
+class IObservable(IWattleflow, ABC):
+    """
+    IObservable - Observer/Reactive Programming Interface desing pattern
+                  abstract interface.
+
+    Interface:
+        subscribe(self, observer: IObserver):
+    """
+
+    @abstractmethod
+    def subscribe(self, observer: IObserver):
+        pass
+
+
+# State interfaces
+# State (IState, IStateContext)
+class IState(IWattleflow, ABC):
+    """
+    IState - State abstract interface.
+    """
+
+    pass
+
+
+class IStateContext(IWattleflow, ABC):
+    """
+    IStateContext - State abstract interface.
+    """
+
+    pass
+
+
+# Strategy interfaces
+# Strategy IStrategy, IStrategyContext
+class IStrategy(IWattleflow, ABC):
+    """
+    IStrategy - Strategy abstract interface.
+    """
+
+    pass
+
+    @abstractmethod
+    def execute(self, *args, **kwargs):
+        pass
+
+
+class IStrategyContext(IWattleflow, ABC):
+    """
+    IStrategyContext - Strategy abstract interface.
+    """
+
+    @abstractmethod
+    def set_strategy(self, strategy: IStrategy) -> None:
+        pass
+
+    @abstractmethod
+    def execute_strategy(self, *args, **kwargs) -> Any:
+        pass
+
+
+# Template method (ITemplate)
+class ITemplate(IWattleflow, ABC):
+    def process(self):
+        """The template method defining the steps of the process."""
+        self.initialise()
+        self.perform_task()
+        self.finalise()
+
+    @abstractmethod
+    def initialise(self):
+        """Step to be implemented by subclasses for initial setup."""
+        pass
+
+    @abstractmethod
+    def perform_task(self):
+        """The main task to be implemented by subclasses."""
+        pass
+
+    @abstractmethod
+    def finalise(self):
+        """Step to be implemented by subclasses to clean up or finalise."""
+        pass
+
+
+# Visitor interfaces
+# Visitor (IVisitor IElement)
+class IVisitor(IWattleflow, ABC):
+    """
+    IVisitor - Abstract interface for Visitor pattern.
+    """
+
+    @abstractmethod
+    def visit(self, element: "IElement") -> Any:
+        pass
+
+
+class IElement(IWattleflow, ABC):
+    """
+    IElement - Abstract interface for elements that accept visitors.
+    """
+
+    @abstractmethod
+    def accept(self, visitor: IVisitor):
+        pass