PyEventEngine 0.2.1__tar.gz → 0.3.0.post1__tar.gz

{PyEventEngine-0.2.1 → pyeventengine-0.3.0.post1}/EventEngine/Core/__init__.py

@@ -1,13 +1,12 @@
-from __future__ import annotations
-
 import logging
 import sys
 import time
 
-__all__ = ['set_logger', 'LOG_LEVEL_EVENT', 'Topic', 'RegularTopic', 'PatternTopic', 'EventHook', 'EventEngine', 'LOGGER']
+__all__ = ['set_logger', 'LOG_LEVEL_EVENT', 'Topic', 'RegularTopic', 'PatternTopic', 'EventHook', 'EventEngine', 'LOGGER', 'use_cpp_override']
 LOGGER: logging.Logger | None = None
+DEBUG = False
 LOG_LEVEL = logging.INFO
-LOG_LEVEL_EVENT = LOG_LEVEL - 1
+LOG_LEVEL_EVENT = LOG_LEVEL - 5
 
 
 class ColoredFormatter(logging.Formatter):
@@ -83,15 +82,18 @@ def set_logger(logger: logging.Logger):
     global LOGGER
     LOGGER = logger
 
+    _event.LOGGER = LOGGER.getChild('Event')
 
-_ = get_logger()
 
-# use c++ optimized module
-try:
-    from ._Topic_c import Topic, RegularTopic, PatternTopic
-except Exception as _:
-    from ._Topic import Topic, RegularTopic, PatternTopic
+def use_cpp_override():
+    try:
+        from ._topic_c import Topic, RegularTopic, PatternTopic
+        from . import _topic as _Topic_native
+    except Exception as _:
+        LOGGER.warning(_)
 
-    LOGGER.warning(_)
 
-from ._Event import EventHook, EventEngine
+_ = get_logger()
+
+from ._topic import Topic, RegularTopic, PatternTopic
+from ._event import EventHook, EventEngine

PyEventEngine-0.2.1/EventEngine/Core/_Event.py → pyeventengine-0.3.0.post1/EventEngine/Core/_event.py

@@ -1,13 +1,22 @@
-from __future__ import annotations
-
 import datetime
-import queue
-import threading
+import enum
+import inspect
 import time
 import traceback
-from typing import Iterable
+from collections import deque
+from logging import Logger
+from threading import Thread, Semaphore
+from typing import Iterable, TypedDict, NotRequired, Callable
+
+from . import LOGGER, LOG_LEVEL_EVENT, Topic, DEBUG
+
+LOGGER = LOGGER.getChild('Event')
+
 
-from . import LOGGER, LOG_LEVEL_EVENT, Topic
+class EventDict(TypedDict):
+    topic: str
+    args: NotRequired[tuple]
+    kwargs: NotRequired[dict]
 
 
 class EventHookBase(object):
@@ -17,31 +26,19 @@ class EventHookBase(object):
     and a list of handler to process data
     """
 
-    def __init__(self, topic: Topic, handler: list[callable] | callable | None = None):
+    def __init__(self, topic: Topic, logger: Logger = None, max_size: int = None):
         self.topic = topic
-
-        if callable(handler):
-            self.handlers = [handler]
-        elif isinstance(handler, Iterable):
-            self.handlers = []
-            for hdl in handler:
-                if callable(hdl):
-                    self.handlers.append(hdl)
-                else:
-                    raise ValueError(f'invalid handler {hdl}')
-        elif handler is None:
-            self.handlers = []
-        else:
-            raise ValueError(f'Invalid handler {handler}')
+        self.logger = LOGGER.getChild(f'EventHook.{topic}') if logger is None else logger
+        self.handlers: deque[Callable] = deque(maxlen=max_size)
 
     def __call__(self, *args, **kwargs):
         self.trigger(topic=self.topic, args=args, kwargs=kwargs)
 
-    def __iadd__(self, handler):
+    def __iadd__(self, handler: Callable):
         self.add_handler(handler)
         return self
 
-    def __isub__(self, handler):
+    def __isub__(self, handler: Callable):
         self.remove_handler(handler)
         return self
 
@@ -56,88 +53,134 @@ class EventHookBase(object):
             try:
                 try:
                     handler(topic=topic, *args, **kwargs)
-                except TypeError:
-                    handler(*args, **kwargs)
+                except TypeError as e:
+                    if e.__str__().endswith("unexpected keyword argument 'topic'"):
+                        handler(*args, **kwargs)
+                    else:
+                        raise e
             except Exception as _:
-                LOGGER.error(traceback.format_exc())
+                self.logger.error(traceback.format_exc())
 
-    def add_handler(self, handler: callable):
+    def add_handler(self, handler: Callable):
+        if handler in self.handlers:
+            LOGGER.warning(f'Handler {handler} already in {self}. This action might cause it to trigger twice.')
         self.handlers.append(handler)
 
-    def remove_handler(self, handler: callable):
-        self.handlers.remove(handler)
+    def remove_handler(self, handler: Callable):
+        try:
+            self.handlers.remove(handler)
+        except ValueError as e:
+            self.logger.error(f'Handler {handler} not found in {self}.')
 
 
 class EventHook(EventHookBase):
-    def __init__(self, topic, handler):
-        self.logger = LOGGER.getChild(f'EventHook.{topic}')
-        super().__init__(topic=topic, handler=handler)
+    def __init__(self, topic: Topic, logger: Logger = None, max_size: int = None, handler: list[Callable] | Callable | None = None):
+        super().__init__(topic=topic, logger=logger, max_size=max_size)
+        self.with_topic: deque[bool] = deque()
+
+        if handler is None:
+            pass
+        elif callable(handler):
+            self.add_handler(handler)
+        elif isinstance(handler, Iterable):
+            for _handler in handler:
+                self.add_handler(handler=_handler)
+        else:
+            raise ValueError(f'Invalid handler {handler}, expect a Callable or a list of Callable.')
 
     def trigger(self, topic: Topic, args: tuple = None, kwargs: dict = None):
         ts = time.time()
-
         if args is None:
             args = ()
 
         if kwargs is None:
             kwargs = {}
 
-        for handler in self.handlers:
+        for handler, with_topic in zip(self.handlers, self.with_topic):
             try:
-                try:
+                if with_topic:
                     handler(topic=topic, *args, **kwargs)
-                except TypeError:
+                else:
                     handler(*args, **kwargs)
             except Exception as _:
                 self.logger.error(traceback.format_exc())
 
-        self.logger.log(LOG_LEVEL_EVENT, f'EventHook {self.topic} tasks triggered {len(self.handlers):,} handlers, complete in {(time.time() - ts) * 1000:.3f}ms')
+        if DEBUG:
+            self.logger.log(LOG_LEVEL_EVENT, f'EventHook {self.topic} tasks triggered {len(self.handlers):,} handlers, complete in {(time.time() - ts) * 1000:.3f}ms.')
+
+    def add_handler(self, handler: Callable, with_topic: bool = None):
+        sig = inspect.signature(handler)
+
+        if with_topic is None:
+            for param in sig.parameters.values():
+                if param.name == 'topic' or param.kind == param.VAR_KEYWORD:
+                    with_topic = True
+                    break
+
+        super().add_handler(handler=handler)
+        self.with_topic.append(with_topic)
+
+    def remove_handler(self, handler: Callable):
+        try:
+            idx = self.handlers.index(handler)
+            self.handlers.__delitem__(idx)
+            self.with_topic.__delitem__(idx)
+        except ValueError as e:
+            pass
 
 
 class EventEngineBase(object):
     EventHook = EventHook
 
-    def __init__(self, max_size=0):
-        self.lock = threading.Lock()
-
-        self._max_size = max_size
-        self._queue: queue.Queue = queue.Queue(maxsize=self._max_size)
+    def __init__(self, logger: Logger = None, buffer_size: int = 0):
+        self.logger = LOGGER.getChild(f'EventEngine') if logger is None else logger
+        self._buffer_size = buffer_size
+        self._put_lock = Semaphore(self._buffer_size)
+        self._get_lock = Semaphore(0)
+        self._deque: deque[EventDict] = deque(maxlen=buffer_size if buffer_size else None)
         self._active: bool = False
-        self._engine: threading.Thread = threading.Thread(target=self._run, name='EventEngine')
+        self._engine: Thread = Thread(target=self._run, name='EventEngine')
         self._event_hooks: dict[Topic, EventHook] = {}
 
+        if buffer_size and buffer_size < 8:
+            self.logger.info(f'buffer_size={buffer_size} too small. This might cause a dead lock.')
+
     def _run(self) -> None:
         """
         Get event from queue and then process it.
         """
         while self._active:
+            self._get_lock.acquire(blocking=True, timeout=None)
+
             try:
-                event_dict = self._queue.get(block=True, timeout=1)
-                topic = event_dict['topic']
-                args = event_dict.get('args', ())
-                kwargs = event_dict.get('kwargs', {})
-                self._process(topic, *args, **kwargs)
-            except queue.Empty:
-                pass
+                event_dict = self._deque.pop()
+            except IndexError as e:
+                if not self._active:
+                    return
+                raise e
+
+            topic = event_dict['topic']
+            args = event_dict.get('args', ())
+            kwargs = event_dict.get('kwargs', {})
+            self._process(topic=topic, *args, **kwargs)
+
+            if self._buffer_size:
+                self._put_lock.release()
 
     def _process(self, topic: str, *args, **kwargs) -> None:
         """
         distribute data to registered event hook in the order of registration
         """
-        for _ in list(self._event_hooks):
-            m = _.match(topic=topic)
-            if m:
-                event_hook = self._event_hooks.get(_)
-
-                if event_hook is not None:
-                    event_hook.trigger(topic=m, args=args, kwargs=kwargs)
+        for event_topic, event_hook in self._event_hooks.items():
+            if matched_topic := event_topic.match(topic=topic):
+                event_hook.trigger(topic=matched_topic, args=args, kwargs=kwargs)
 
     def start(self) -> None:
         """
         Start event engine to process events and generate timer events.
         """
         if self._active:
-            LOGGER.warning('EventEngine already started!')
+            self.logger.warning(f'{self} already started!')
             return
 
         self._active = True
@@ -148,10 +191,11 @@ class EventEngineBase(object):
         Stop event engine.
         """
         if not self._active:
-            LOGGER.warning('EventEngine already stopped!')
+            self.logger.warning('EventEngine already stopped!')
             return
 
         self._active = False
+        self._get_lock.release()
         self._engine.join()
 
     def put(self, topic: str | Topic, block: bool = True, timeout: float = None, *args, **kwargs):
@@ -181,6 +225,9 @@ class EventEngineBase(object):
         elif not isinstance(topic, str):
             raise ValueError(f'Invalid topic {topic}')
 
+        if self._buffer_size:
+            self._put_lock.acquire()
+
         event_dict = {'topic': topic}
 
         if args is not None:
@@ -189,7 +236,9 @@ class EventEngineBase(object):
         if kwargs is not None:
             event_dict['kwargs'] = kwargs
 
-        self._queue.put(event_dict, block=block, timeout=timeout)
+        self._deque.append(event_dict)
+
+        self._get_lock.release()
 
     def register_hook(self, hook: EventHook) -> None:
         """
@@ -208,7 +257,7 @@ class EventEngineBase(object):
         if topic in self._event_hooks:
             self._event_hooks.pop(topic)
 
-    def register_handler(self, topic: Topic, handler: Iterable[callable] | callable) -> None:
+    def register_handler(self, topic: Topic, handler: Iterable[Callable] | Callable) -> None:
         """
         Register one or more handler for a specific topic
         """
@@ -217,11 +266,11 @@ class EventEngineBase(object):
             raise TypeError(f'Invalid topic {topic}')
 
         if topic not in self._event_hooks:
-            self._event_hooks[topic] = self.EventHook(topic=topic, handler=handler)
+            self._event_hooks[topic] = self.EventHook(topic=topic, handler=handler, logger=self.logger.getChild(topic.value))
         else:
             self._event_hooks[topic].add_handler(handler)
 
-    def unregister_handler(self, topic: Topic, handler: callable) -> None:
+    def unregister_handler(self, topic: Topic, handler: Callable) -> None:
         """
         Unregister an existing handler function.
         """
@@ -229,23 +278,18 @@ class EventEngineBase(object):
             self._event_hooks[topic].remove_handler(handler=handler)
 
     @property
-    def max_size(self):
-        return self._max_size
-
-    @max_size.setter
-    def max_size(self, size: int):
-        self._max_size = size
-        self._queue.maxsize = size
+    def buffer_size(self):
+        return self._buffer_size
 
 
 class EventEngine(EventEngineBase):
     EventHook = EventHook
 
-    def __init__(self, max_size=0):
-        super().__init__(max_size=max_size)
-        self.timer: dict[float | str, threading.Thread] = {}
+    def __init__(self, buffer_size=0):
+        super().__init__(buffer_size=buffer_size)
+        self.timer: dict[float | str, Thread] = {}
 
-    def register_handler(self, topic, handler):
+    def register_handler(self, topic: Topic | str | enum.Enum, handler: Callable):
         topic = Topic.cast(topic)
         super().register_handler(topic=topic, handler=handler)
 
@@ -277,20 +321,20 @@ class EventEngine(EventEngineBase):
 
         if interval == 1:
             topic = Topic('EventEngine.Internal.Timer.Second')
-            timer = threading.Thread(target=self._second_timer, kwargs={'topic': topic})
+            timer = Thread(target=self._second_timer, kwargs={'topic': topic})
         elif interval == 60:
             topic = Topic('EventEngine.Internal.Timer.Minute')
-            timer = threading.Thread(target=self._minute_timer, kwargs={'topic': topic})
+            timer = Thread(target=self._minute_timer, kwargs={'topic': topic})
         else:
             topic = Topic(f'EventEngine.Internal.Timer.{interval}')
-            timer = threading.Thread(target=self._run_timer, kwargs={'interval': interval, 'topic': topic, 'activate_time': activate_time})
+            timer = Thread(target=self._run_timer, kwargs={'interval': interval, 'topic': topic, 'activate_time': activate_time})
 
         if interval not in self.timer:
             self.timer[interval] = timer
             timer.start()
         else:
             if activate_time is not None:
-                LOGGER.debug(f'Timer thread with interval [{datetime.timedelta(seconds=interval)}] already initialized! Argument [activate_time] takes no effect!')
+                self.logger.debug(f'Timer thread with interval [{datetime.timedelta(seconds=interval)}] already initialized! Argument [activate_time] takes no effect!')
 
         return topic
 

PyEventEngine-0.2.1/EventEngine/Core/_Topic.py → pyeventengine-0.3.0.post1/EventEngine/Core/_topic.py

@@ -1,8 +1,7 @@
-from __future__ import annotations
-
 import re
 from enum import Enum
 from string import Formatter
+from typing import Self, Type
 
 
 class Topic(dict):
@@ -30,29 +29,33 @@ class Topic(dict):
     def __hash__(self):
         return self.value.__hash__()
 
-    def match(self, topic: str) -> Topic | None:
+    def match(self, topic: str) -> Self | None:
         if self._value == topic:
-            return self.__class__(topic=topic)
+            # return self.__class__(topic=topic)
+            return self
         else:
             return None
 
     @classmethod
-    def cast(cls, topic: Topic | str | Enum, dtype=None) -> Topic:
-        if isinstance(topic, Enum):
-            topic = topic.value
-        elif isinstance(topic, Topic):
+    def cast(cls, topic: Self | str | Enum, dtype: Type[Self] = None) -> Self:
+        if isinstance(topic, cls):
             return topic
-
-        if dtype is None:
-            if re.search(r'{(.+?)}', topic):
-                t = PatternTopic(pattern=topic)
-            elif '*' in topic or '+' in topic or '|' in topic:
-                re.compile(pattern=topic)
-                t = RegularTopic(pattern=topic)
+        elif isinstance(topic, Enum):
+            t = topic.value
+            return cls.cast(t)
+        elif isinstance(topic, str):
+            if dtype is None:
+                if re.search(r'{(.+?)}', topic):
+                    t = PatternTopic(pattern=topic)
+                elif '*' in topic or '+' in topic or '|' in topic:
+                    re.compile(pattern=topic)
+                    t = RegularTopic(pattern=topic)
+                else:
+                    t = Topic(topic=topic)
             else:
-                t = Topic(topic=topic)
+                t = dtype(topic)
         else:
-            t = dtype(topic)
+            raise NotImplementedError(f'Can not cast {topic} into {cls}.')
 
         return t
 
@@ -89,18 +92,41 @@ class PatternTopic(Topic):
     def __call__(self, **kwargs):
         return self.format_map(kwargs)
 
+    # @classmethod
+    # def extract_mapping(cls, target: str, pattern: str):
+    #     pattern = re.escape(pattern)
+    #     regex = re.sub(r'\\{(.+?)\\}', r'(?P<_\1>.+)', pattern)
+    #     match = re.match(regex, target)
+    #     if match:
+    #         values = list(match.groups())
+    #         keys = re.findall(r'\\{(.+?)\\}', pattern)
+    #         m = dict(zip(keys, values))
+    #         return m
+    #     else:
+    #         raise Topic.Error(f'pattern {pattern} not in string {target} found!')
+
     @classmethod
     def extract_mapping(cls, target: str, pattern: str):
-        pattern = re.escape(pattern)
-        regex = re.sub(r'\\{(.+?)\\}', r'(?P<_\1>.+)', pattern)
-        match = re.match(regex, target)
-        if match:
-            values = list(match.groups())
-            keys = re.findall(r'\\{(.+?)\\}', pattern)
-            m = dict(zip(keys, values))
-            return m
-        else:
-            raise Topic.Error(f'pattern {pattern} not in string {target} found!')
+        dictionary = {}
+
+        result_parts = target.split('.')
+        pattern_parts = pattern.split('.')
+
+        # Check if the number of parts in result and pattern are the same
+        if len(result_parts) != len(pattern_parts):
+            return dictionary
+
+        # Generate the mapping dictionary
+        for result_part, pattern_part in zip(result_parts, pattern_parts):  # type: str
+            if pattern_part[0] == '{' and pattern_part[-1] == '}':
+                content = pattern_part[1:-1]
+                dictionary[content] = result_part
+            else:
+                if result_part != pattern_part:
+                    dictionary.clear()
+                    break
+
+        return dictionary
 
     def format_map(self, mapping: dict) -> Topic:
         for key in self.keys():

pyeventengine-0.3.0.post1/EventEngine/Core/_topic_c.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import ctypes
+import pathlib
+import platform
+import re
+
+from ._topic import Topic, RegularTopic as RegularTopicBase, PatternTopic as PatternTopicBase
+
+__all__ = ['Topic', 'RegularTopic', 'PatternTopic']
+
+topic_lib = None
+
+if platform.system() == 'Windows':
+    package_name = 'topic_api.(.*).pyd'
+elif platform.system() == 'Darwin':
+    package_name = '^topic_api(.*).so$'
+else:
+    package_name = '^topic_api(.*).so$'
+
+ROOT_DIR = pathlib.Path(__file__).parent.parent
+ENCODING = 'utf-8'
+
+for _ in ROOT_DIR.iterdir():
+    if lib_path := re.search(package_name, _.name):
+        topic_lib = ctypes.CDLL(str(_))
+        break
+
+# Load the shared library
+if topic_lib is None:
+    raise ImportError(f'EventEngine.Topic c extension {package_name} not found in {ROOT_DIR}! Fallback to native lib!')
+
+# Function prototypes
+# topic_lib.delete_vector.restype = [ctypes.POINTER]
+topic_lib.get_vector_value.restype = ctypes.c_char_p
+topic_lib.is_regular_match.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
+topic_lib.is_regular_match.restype = ctypes.c_int
+
+
+# Define the RegularTopic class in Python
+class RegularTopic(RegularTopicBase):
+    """
+    topic in regular expression. e.g. "TickData.(.+).((SZ)|(SH)).((Realtime)|(History))"
+    """
+
+    def match(self, topic: str):
+        match = topic_lib.is_regular_match(topic.encode(ENCODING), self._value.encode(ENCODING))
+
+        if match:
+            return Topic(topic=topic, pattern=self.value)
+        else:
+            return None
+
+
+# Define the PatternTopic class in Python
+class PatternTopic(PatternTopicBase):
+    """
+    topic for event hook. e.g. "TickData.{symbol}.{market}.{flag}"
+    """
+
+    def match(self, topic: str):
+        mapping = self.extract_mapping(target=topic, pattern=self._value, encoding=ENCODING)
+
+        if mapping:
+            return Topic(topic, pattern=self._value, **mapping)
+        else:
+            return None
+
+    @classmethod
+    def extract_mapping(cls, target: str, pattern: str, encoding: str = ENCODING) -> dict[str, str]:
+        # noinspection PyArgumentList
+        keys_ptr, values_ptr = ctypes.POINTER(ctypes.c_void_p)(), ctypes.POINTER(ctypes.c_void_p)()
+        mapping = {}
+
+        topic_lib.extract_mapping(
+            target.encode(encoding),
+            pattern.encode(encoding),
+            ctypes.byref(keys_ptr),
+            ctypes.byref(values_ptr)
+        )
+
+        for i in range(topic_lib.vector_size(ctypes.byref(keys_ptr))):
+            key = topic_lib.get_vector_value(ctypes.byref(keys_ptr), i)
+            value = topic_lib.get_vector_value(ctypes.byref(values_ptr), i)
+            # print(key, value)
+            mapping[key.decode(encoding)] = value.decode(encoding)
+
+        # topic_lib.delete_vector(ctypes.byref(keys_ptr))
+        # topic_lib.delete_vector(ctypes.byref(values_ptr))
+
+        del keys_ptr
+        del values_ptr
+
+        return mapping

pyeventengine-0.3.0.post1/EventEngine/__init__.py

@@ -0,0 +1,3 @@
+__version__ = '0.3.0.post1'
+
+from .Core import *

{PyEventEngine-0.2.1 → pyeventengine-0.3.0.post1}/EventEngine/cpp/topic_api.cpp

@@ -2,29 +2,30 @@
 #include <regex>
 #include <string>
 #include <unordered_map>
+#include <utility>
 #include <vector>
 
 extern "C" {
-    #include <stdio.h>
-    #include <stdlib.h>
+#include <stdlib.h>
 }
 
 class Topic : public std::unordered_map<std::string, std::string> {
 public:
     class Error : public std::exception {
     public:
-        explicit Error(const std::string& msg) : message(msg) {}
-        const char* what() const noexcept override { return message.c_str(); }
+        explicit Error(std::string msg) : message(std::move(msg)) {}
+
+        [[nodiscard]] const char *what() const noexcept override { return message.c_str(); }
 
     private:
         std::string message;
     };
 
-    explicit Topic(const std::string& topic) : _value(topic) {}
+    explicit Topic(std::string topic) : _value(std::move(topic)) {}
 
     std::string value() const { return _value; }
 
-    Topic match(const std::string& topic) const {
+    virtual Topic match(const std::string &topic) const {
         if (_value == topic) {
             return Topic(topic);
         } else {
@@ -37,11 +38,20 @@ public:
 
 class RegularTopic : public Topic {
 public:
-    explicit RegularTopic(const std::string& pattern) : Topic(pattern) {}
+    explicit RegularTopic(const std::string &pattern) : Topic(pattern) {}
 
-    Topic match(const std::string& topic) const {
-        std::regex regex(_value);
+    static int is_match(const std::string &topic, const std::string &pattern) {
+        std::regex regex(pattern);
         if (std::regex_match(topic, regex)) {
+            return 1;
+        } else {
+            return 0;
+        }
+    }
+
+    Topic match(const std::string &topic) const override {
+        int result = is_match(topic, _value);
+        if (result == 1) {
             Topic match(topic);
             match["pattern"] = _value;
             return match;
@@ -53,14 +63,14 @@ public:
 
 class PatternTopic : public Topic {
 public:
-    explicit PatternTopic(const std::string& pattern) : Topic(pattern) {}
+    explicit PatternTopic(const std::string &pattern) : Topic(pattern) {}
 
-    Topic format_map(const std::unordered_map<std::string, std::string>& mapping) const {
+    Topic format_map(const std::unordered_map<std::string, std::string> &mapping) const {
         std::string result = _value;
 
         std::vector<std::string> contentVec = keys();
 
-        for (const auto& content : contentVec) {
+        for (const auto &content: contentVec) {
             auto it = mapping.find(content);
             if (it != mapping.end()) {
                 std::string replacement = it->second;
@@ -79,7 +89,6 @@ public:
     std::vector<std::string> keys() const {
         std::vector<std::string> contentVec;
         std::vector<std::string> keys;
-        std::string pattern = _value;
 
         size_t startPos = _value.find('{');
         size_t endPos;
@@ -98,18 +107,18 @@ public:
         return keys;
     }
 
-    Topic match(const std::string& topic) const {
-        try {
-            std::unordered_map<std::string, std::string> keyword_dict = extract_mapping(topic, _value);
-            Topic match(topic);
-            match.insert(keyword_dict.begin(), keyword_dict.end());
-            return match;
-        } catch (const Error&) {
+    Topic match(const std::string &topic) const override {
+        std::unordered_map<std::string, std::string> keyword_dict = extract_mapping(topic, _value);
+        if (keyword_dict.empty()) {
             return Topic("");
         }
+
+        Topic match(topic);
+        match.insert(keyword_dict.begin(), keyword_dict.end());
+        return match;
     }
 
-    static std::unordered_map<std::string, std::string> extract_mapping(const std::string& target, const std::string& pattern) {
+    static std::unordered_map<std::string, std::string> extract_mapping(const std::string &target, const std::string &pattern) {
         std::unordered_map<std::string, std::string> dictionary;
 
         std::vector<std::string> resultParts;
@@ -141,7 +150,6 @@ public:
 
         // Check if the number of parts in result and pattern are the same
         if (resultParts.size() != patternParts.size()) {
-            throw Error("Pattern not match");
             return dictionary;
         }
 
@@ -157,86 +165,91 @@ public:
             } else {
                 if (resultPart != patternPart) {
                     dictionary.clear();
-                    throw Error("Pattern not match");
                     return dictionary;
                 }
             }
         }
-
         return dictionary;
     }
 };
 
 extern "C" {
-    Topic* create_topic(const char* topic) {
-        return new Topic(topic);
-    }
+Topic *create_topic(const char *topic) {
+    return new Topic(topic);
+}
 
-    void get_topic_value(const Topic* topic, char* buffer, size_t bufferSize) {
-        std::string value = topic->value();
-        strncpy(buffer, value.c_str(), bufferSize - 1);
-        buffer[bufferSize - 1] = '\0';
-    }
+void get_topic_value(const Topic *topic, char *buffer, size_t bufferSize) {
+    std::string value = topic->value();
+    strncpy(buffer, value.c_str(), bufferSize - 1);
+    buffer[bufferSize - 1] = '\0';
+}
 
-    const char* get_topic_value_no_buffer(const Topic* topic) {
-        return topic->_value.c_str();
-    }
+const char *get_topic_value_no_buffer(const Topic *topic) {
+    return topic->_value.c_str();
+}
 
-    void delete_topic(Topic* topic) {
-        delete topic;
-    }
+void delete_topic(Topic *topic) {
+    delete topic;
+}
 
-    Topic* match_topic(const Topic* topic, const char* match_topic) {
-        return new Topic(topic->match(match_topic));
-    }
+Topic *match_topic(const Topic *topic, const char *match_topic) {
+    return new Topic(topic->match(match_topic));
+}
 
-    RegularTopic* create_regular_topic(const char* pattern) {
-        return new RegularTopic(pattern);
-    }
+RegularTopic *create_regular_topic(const char *pattern) {
+    return new RegularTopic(pattern);
+}
 
-    Topic* match_regular_topic(const RegularTopic* topic, const char* match_topic) {
-        return new Topic(topic->match(match_topic));
-    }
+Topic *match_regular_topic(const RegularTopic *topic, const char *match_topic) {
+    return new Topic(topic->match(match_topic));
+}
 
-    PatternTopic* create_pattern_topic(const char* pattern) {
-        return new PatternTopic(pattern);
-    }
+PatternTopic *create_pattern_topic(const char *pattern) {
+    return new PatternTopic(pattern);
+}
 
-    Topic* match_pattern_topic(const PatternTopic* topic, const char* match_topic) {
-        return new Topic(topic->match(match_topic));
-    }
+Topic *match_pattern_topic(const PatternTopic *topic, const char *match_topic) {
+    return new Topic(topic->match(match_topic));
+}
 
-    std::vector<std::string>* get_pattern_topic_keys(const PatternTopic* topic) {
-        return new std::vector<std::string>(topic->keys());
-    }
+std::vector<std::string> *get_pattern_topic_keys(const PatternTopic *topic) {
+    return new std::vector<std::string>(topic->keys());
+}
 
-    void extract_mapping(const char* target, const char* pattern, std::vector<std::string>* keys, std::vector<std::string>* values) {
-        std::string target_str(target);
-        std::string pattern_str(pattern);
+int is_regular_match(const char *topic, const char *pattern) {
+    std::string topicStr(topic);
+    std::string patternStr(pattern);
+    int result = RegularTopic::is_match(topicStr, patternStr);
+    return result;
+}
 
-        std::unordered_map<std::string, std::string> mapping = PatternTopic::extract_mapping(target_str, pattern_str);
+void extract_mapping(const char *target, const char *pattern, std::vector<std::string> *keys, std::vector<std::string> *values) {
+    std::string target_str(target);
+    std::string pattern_str(pattern);
 
-        // Populate the keys and values vectors
-        for (const auto& entry : mapping) {
-            keys->push_back(entry.first);
-            values->push_back(entry.second);
-        }
-    }
+    std::unordered_map<std::string, std::string> mapping = PatternTopic::extract_mapping(target_str, pattern_str);
 
-    const char* get_vector_value(const std::vector<std::string>* vec, int index) {
-        if (index >= 0 && index < static_cast<int>(vec->size()))
-            return vec->at(index).c_str();
-        else
-            return "";
+    // Populate the keys and values vectors
+    for (const auto &entry: mapping) {
+        keys->push_back(entry.first);
+        values->push_back(entry.second);
     }
+}
 
-    const int vector_size(const std::vector<std::string>* v){
-        return v->size();
-    }
+const char *get_vector_value(const std::vector<std::string> *vec, int index) {
+    if (index >= 0 && index < static_cast<int>(vec->size()))
+        return vec->at(index).c_str();
+    else
+        return "";
+}
 
-    void delete_vector(std::vector<std::string>* vec) {
-        delete vec;
-    }
+int vector_size(const std::vector<std::string> *vec) {
+    return vec->size();
+}
+
+void delete_vector(const std::vector<std::string> *vec) {
+    delete vec;
+}
 }
 
 int main() {
@@ -250,22 +263,24 @@ int main() {
     std::cout << match2.value() << std::endl;
 
     PatternTopic patternTopic("TickData.{symbol}.{market}.{flag}");
-    for (std::string i: patternTopic.keys())
-    std::cout << i << std::endl;
+    for (const std::string &i: patternTopic.keys())
+        std::cout << i << std::endl;
 
-    Topic formatted = patternTopic.format_map({{"symbol", "AAPL"}, {"market", "NASDAQ"}, {"flag", "Realtime"}});
+    Topic formatted = patternTopic.format_map({{"symbol", "AAPL"},
+                                               {"market", "NASDAQ"},
+                                               {"flag",   "Realtime"}});
     std::cout << formatted.value() << std::endl;
 
     Topic match3 = patternTopic.match("TickData.ABC.NYSE.Realtime");
     Topic match4 = patternTopic.match("OtherData.XYZ.LSE.History");
 
     std::cout << "topic: " << match3.value() << std::endl;
-    for (const auto& entry : match3) {
+    for (const auto &entry: match3) {
         std::cout << entry.first << " : " << entry.second << std::endl;
     }
 
     std::cout << "topic: " << match4.value() << std::endl;
-    for (const auto& entry : match4) {
+    for (const auto &entry: match4) {
         std::cout << entry.first << " : " << entry.second << std::endl;
     }
 

{PyEventEngine-0.2.1/PyEventEngine.egg-info → pyeventengine-0.3.0.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyEventEngine
-Version: 0.2.1
+Version: 0.3.0.post1
 Summary: Basic event engine
 Home-page: https://github.com/BolunHan/PyEventEngine.git
 Author: Bolun.Han
@@ -9,6 +9,8 @@ License: MIT
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

{PyEventEngine-0.2.1 → pyeventengine-0.3.0.post1/PyEventEngine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyEventEngine
-Version: 0.2.1
+Version: 0.3.0.post1
 Summary: Basic event engine
 Home-page: https://github.com/BolunHan/PyEventEngine.git
 Author: Bolun.Han
@@ -9,6 +9,8 @@ License: MIT
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

{PyEventEngine-0.2.1 → pyeventengine-0.3.0.post1}/PyEventEngine.egg-info/SOURCES.txt

@@ -3,10 +3,10 @@ README.md
 setup.cfg
 setup.py
 EventEngine/__init__.py
-EventEngine/Core/_Event.py
-EventEngine/Core/_Topic.py
-EventEngine/Core/_Topic_c.py
 EventEngine/Core/__init__.py
+EventEngine/Core/_event.py
+EventEngine/Core/_topic.py
+EventEngine/Core/_topic_c.py
 EventEngine/cpp/topic_api.cpp
 PyEventEngine.egg-info/PKG-INFO
 PyEventEngine.egg-info/SOURCES.txt

{PyEventEngine-0.2.1 → pyeventengine-0.3.0.post1}/setup.py

@@ -40,6 +40,8 @@ setuptools.setup(
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
         "Operating System :: OS Independent",
     ],
     python_requires='>=3.8',

PyEventEngine-0.2.1/EventEngine/Core/_Topic_c.py

@@ -1,171 +0,0 @@
-from __future__ import annotations
-
-import ctypes
-import pathlib
-import re
-
-__all__ = ['Topic', 'RegularTopic', 'PatternTopic']
-
-topic_lib = None
-package_name = '^topic_api(.*).so$'
-root_dir = pathlib.Path(__file__).parent.parent
-
-for _ in root_dir.iterdir():
-    if lib_path := re.search(package_name, _.name):
-        topic_lib = ctypes.CDLL(str(_))
-        break
-
-# Load the shared library
-if topic_lib is None:
-    raise ImportError(f'EventEngine.Topic c extension {package_name} not found in {root_dir}! Fallback to native lib!')
-
-# Function prototypes
-handler = ctypes.POINTER(ctypes.c_void_p)
-
-topic_lib.create_topic.restype = handler
-topic_lib.create_regular_topic.restype = handler
-topic_lib.create_pattern_topic.restype = handler
-
-topic_lib.get_topic_value.restype = ctypes.c_void_p
-topic_lib.get_topic_value_no_buffer.restype = ctypes.POINTER(ctypes.c_char_p)
-topic_lib.get_vector_value.restype = ctypes.c_char_p
-
-topic_lib.match_topic.restype = handler
-topic_lib.match_regular_topic.restype = handler
-topic_lib.match_pattern_topic.restype = handler
-
-topic_lib.get_pattern_topic_keys.restype = handler
-
-
-class Topic(dict):
-    """
-    topic for event hook. e.g. "TickData.002410.SZ.Realtime"
-    """
-
-    def __init__(self, topic: str, encoding: str = 'utf-8', buffer_size: int = 0, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.encoding = encoding
-        self.buffer_size = buffer_size
-        self.topic = topic_lib.create_topic(topic.encode(self.encoding))
-
-    def __repr__(self):
-        return f'<{self.__class__.__name__}>({self.value}){super().__repr__()}'
-
-    def __str__(self):
-        return self.value
-
-    def __bool__(self):
-        if self.value:
-            return True
-        else:
-            return False
-
-    def __hash__(self):
-        return self.value.__hash__()
-
-    @staticmethod
-    def _get_topic_value(topic: handler | int, buffer_size: int = 1024, encoding: str = 'utf-8'):
-        if buffer_size:
-            buffer = ctypes.create_string_buffer(buffer_size)
-            topic_lib.get_topic_value(topic, buffer, buffer_size)
-            topic_value = buffer.value.decode(encoding)
-        else:
-            topic_ptr = topic_lib.get_topic_value_no_buffer(topic)
-            topic_value = ctypes.string_at(topic_ptr).decode(encoding)
-
-        return topic_value
-
-    @property
-    def value(self) -> str:
-        return self._get_topic_value(topic=self.topic, buffer_size=self.buffer_size, encoding=self.encoding)
-
-    def match(self, topic: str):
-        match = topic_lib.match_topic(self.topic, topic.encode(self.encoding))
-
-        if self._get_topic_value(match):
-            return Topic(topic)
-        else:
-            return None
-
-    def __del__(self):
-        topic_lib.delete_topic(self.topic)
-
-
-# Define the RegularTopic class in Python
-class RegularTopic(Topic):
-    """
-    topic in regular expression. e.g. "TickData.(.+).((SZ)|(SH)).((Realtime)|(History))"
-    """
-
-    def __init__(self, pattern: str, encoding: str = 'utf-8', buffer_size: int = 0, *args, **kwargs):
-        dict.__init__(self, *args, **kwargs)
-        self.encoding = encoding
-        self.buffer_size = buffer_size
-        self.topic = topic_lib.create_pattern_topic(pattern.encode(self.encoding))
-
-    def match(self, topic: str):
-        match = topic_lib.match_regular_topic(self.topic, topic.encode(self.encoding))
-
-        if _ := self._get_topic_value(match):
-            return Topic(_, pattern=self.value)
-        else:
-            return None
-
-
-# Define the PatternTopic class in Python
-class PatternTopic(Topic):
-    """
-    topic for event hook. e.g. "TickData.{symbol}.{market}.{flag}"
-    """
-
-    def __init__(self, pattern: str, encoding: str = 'utf-8', buffer_size: int = 0, *args, **kwargs):
-        dict.__init__(self, *args, **kwargs)
-        self.encoding = encoding
-        self.buffer_size = buffer_size
-        self.topic = topic_lib.create_regular_topic(pattern.encode(self.encoding))
-
-    def __call__(self, **kwargs):
-        return self.format_map(kwargs)
-
-    def match(self, topic: str):
-        match = topic_lib.match_pattern_topic(self.topic, topic.encode(self.encoding))
-
-        if _ := self._get_topic_value(match):
-            return Topic(_, pattern=self.value, **self.extract_mapping(target=topic, pattern=self.value, encoding=self.encoding))
-        else:
-            return None
-
-    @classmethod
-    def extract_mapping(cls, target: str, pattern: str, encoding: str = 'utf-8') -> dict[str, str]:
-        # noinspection PyArgumentList
-        keys_ptr, values_ptr = ctypes.POINTER(ctypes.c_void_p)(), ctypes.POINTER(ctypes.c_void_p)()
-        mapping = {}
-
-        topic_lib.extract_mapping(
-            target.encode(encoding),
-            pattern.encode(encoding),
-            ctypes.byref(keys_ptr),
-            ctypes.byref(values_ptr)
-        )
-
-        for i in range(topic_lib.vector_size(ctypes.byref(keys_ptr))):
-            mapping[topic_lib.get_vector_value(ctypes.byref(keys_ptr), i).decode(encoding)] = topic_lib.get_vector_value(ctypes.byref(values_ptr), i).decode(encoding)
-
-        return mapping
-
-    def keys(self) -> list[str]:
-        keys = []
-        keys_ptr = topic_lib.get_pattern_topic_keys(self.topic)
-
-        for i in range(topic_lib.vector_size(keys_ptr)):
-            keys.append(topic_lib.get_vector_value(keys_ptr, i).decode(self.encoding))
-
-        topic_lib.delete_vector(keys_ptr)
-        return keys
-
-    def format_map(self, mapping: dict) -> Topic:
-        for key in self.keys():
-            if key not in mapping:
-                mapping[key] = f'{{{key}}}'
-
-        return Topic(self.value.format_map(mapping))

PyEventEngine-0.2.1/EventEngine/__init__.py

@@ -1,3 +0,0 @@
-__version__ = '0.2.1'
-
-from .Core import *