PyEventEngine 0.3.0.post5__tar.gz → 0.3.2__tar.gz

{PyEventEngine-0.3.0.post5 → pyeventengine-0.3.2}/PKG-INFO

@@ -1,109 +1,109 @@
-Metadata-Version: 2.1
-Name: PyEventEngine
-Version: 0.3.0.post5
-Summary: Basic event engine
-Home-page: https://github.com/BolunHan/PyEventEngine.git
-Author: Bolun.Han
-Author-email: Bolun.Han@outlook.com
-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
-License-File: LICENSE
-
-# PyEventEngine
-
-python native event engine
-
-# Install
-
-```shell
-pip install git+https://github.com/BolunHan/PyEventEngine.git
-```
-
-or
-
-```shell
-pip install PyEventEngine
-```
-
-# Use
-
-## basic usage
-
-```python
-# init event engine
-import time
-from event_engine import EventEngine, Topic
-
-EVENT_ENGINE = EventEngine()
-EVENT_ENGINE.start()
-
-
-# register handler
-def test_handler(msg, **kwargs):
-    print(msg)
-
-
-EVENT_ENGINE.register_handler(topic=Topic('SimpleTopic'), handler=test_handler)
-
-# publish message
-EVENT_ENGINE.put(topic=Topic('SimpleTopic'), msg='topic called')
-time.sleep(1)
-EVENT_ENGINE.stop()
-```
-
-## regular topic
-
-```python
-# init event engine
-import time
-from event_engine import EventEngine, Topic, RegularTopic
-
-EVENT_ENGINE = EventEngine()
-EVENT_ENGINE.start()
-
-
-# register handler
-def test_handler(msg, **kwargs):
-    print(msg)
-
-
-EVENT_ENGINE.register_handler(topic=RegularTopic('RegularTopic.*'), handler=test_handler)
-
-# publish message
-EVENT_ENGINE.put(topic=Topic('RegularTopic.ChildTopic0'), msg='topic called')
-time.sleep(1)
-EVENT_ENGINE.stop()
-```
-
-## timer topic
-
-```python
-# init event engine
-import time
-from event_engine import EventEngine, Topic, RegularTopic
-
-EVENT_ENGINE = EventEngine()
-EVENT_ENGINE.start()
-
-
-# register handler
-def test_handler(**kwargs):
-    print(kwargs)
-
-
-topic = EVENT_ENGINE.get_timer(interval=1)
-EVENT_ENGINE.register_handler(topic=topic, handler=test_handler)
-
-# publish message
-time.sleep(5)
-EVENT_ENGINE.stop()
-```
-
-See more advanced usage at .Demo
+Metadata-Version: 2.1
+Name: PyEventEngine
+Version: 0.3.2
+Summary: Basic event engine
+Home-page: https://github.com/BolunHan/PyEventEngine.git
+Author: Bolun.Han
+Author-email: Bolun.Han@outlook.com
+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.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# PyEventEngine
+
+python native event engine
+
+# Install
+
+```shell
+pip install git+https://github.com/BolunHan/PyEventEngine.git
+```
+
+or
+
+```shell
+pip install PyEventEngine
+```
+
+# Use
+
+## basic usage
+
+```python
+# init event engine
+import time
+from event_engine import EventEngine, Topic
+
+EVENT_ENGINE = EventEngine()
+EVENT_ENGINE.start()
+
+
+# register handler
+def test_handler(msg, **kwargs):
+    print(msg)
+
+
+EVENT_ENGINE.register_handler(topic=Topic('SimpleTopic'), handler=test_handler)
+
+# publish message
+EVENT_ENGINE.put(topic=Topic('SimpleTopic'), msg='topic called')
+time.sleep(1)
+EVENT_ENGINE.stop()
+```
+
+## regular topic
+
+```python
+# init event engine
+import time
+from event_engine import EventEngine, Topic, RegularTopic
+
+EVENT_ENGINE = EventEngine()
+EVENT_ENGINE.start()
+
+
+# register handler
+def test_handler(msg, **kwargs):
+    print(msg)
+
+
+EVENT_ENGINE.register_handler(topic=RegularTopic('RegularTopic.*'), handler=test_handler)
+
+# publish message
+EVENT_ENGINE.put(topic=Topic('RegularTopic.ChildTopic0'), msg='topic called')
+time.sleep(1)
+EVENT_ENGINE.stop()
+```
+
+## timer topic
+
+```python
+# init event engine
+import time
+from event_engine import EventEngine, Topic, RegularTopic
+
+EVENT_ENGINE = EventEngine()
+EVENT_ENGINE.start()
+
+
+# register handler
+def test_handler(**kwargs):
+    print(kwargs)
+
+
+topic = EVENT_ENGINE.get_timer(interval=1)
+EVENT_ENGINE.register_handler(topic=topic, handler=test_handler)
+
+# publish message
+time.sleep(5)
+EVENT_ENGINE.stop()
+```
+
+See more advanced usage at .Demo

{PyEventEngine-0.3.0.post5 → pyeventengine-0.3.2}/PyEventEngine.egg-info/PKG-INFO

@@ -1,109 +1,109 @@
-Metadata-Version: 2.1
-Name: PyEventEngine
-Version: 0.3.0.post5
-Summary: Basic event engine
-Home-page: https://github.com/BolunHan/PyEventEngine.git
-Author: Bolun.Han
-Author-email: Bolun.Han@outlook.com
-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
-License-File: LICENSE
-
-# PyEventEngine
-
-python native event engine
-
-# Install
-
-```shell
-pip install git+https://github.com/BolunHan/PyEventEngine.git
-```
-
-or
-
-```shell
-pip install PyEventEngine
-```
-
-# Use
-
-## basic usage
-
-```python
-# init event engine
-import time
-from event_engine import EventEngine, Topic
-
-EVENT_ENGINE = EventEngine()
-EVENT_ENGINE.start()
-
-
-# register handler
-def test_handler(msg, **kwargs):
-    print(msg)
-
-
-EVENT_ENGINE.register_handler(topic=Topic('SimpleTopic'), handler=test_handler)
-
-# publish message
-EVENT_ENGINE.put(topic=Topic('SimpleTopic'), msg='topic called')
-time.sleep(1)
-EVENT_ENGINE.stop()
-```
-
-## regular topic
-
-```python
-# init event engine
-import time
-from event_engine import EventEngine, Topic, RegularTopic
-
-EVENT_ENGINE = EventEngine()
-EVENT_ENGINE.start()
-
-
-# register handler
-def test_handler(msg, **kwargs):
-    print(msg)
-
-
-EVENT_ENGINE.register_handler(topic=RegularTopic('RegularTopic.*'), handler=test_handler)
-
-# publish message
-EVENT_ENGINE.put(topic=Topic('RegularTopic.ChildTopic0'), msg='topic called')
-time.sleep(1)
-EVENT_ENGINE.stop()
-```
-
-## timer topic
-
-```python
-# init event engine
-import time
-from event_engine import EventEngine, Topic, RegularTopic
-
-EVENT_ENGINE = EventEngine()
-EVENT_ENGINE.start()
-
-
-# register handler
-def test_handler(**kwargs):
-    print(kwargs)
-
-
-topic = EVENT_ENGINE.get_timer(interval=1)
-EVENT_ENGINE.register_handler(topic=topic, handler=test_handler)
-
-# publish message
-time.sleep(5)
-EVENT_ENGINE.stop()
-```
-
-See more advanced usage at .Demo
+Metadata-Version: 2.1
+Name: PyEventEngine
+Version: 0.3.2
+Summary: Basic event engine
+Home-page: https://github.com/BolunHan/PyEventEngine.git
+Author: Bolun.Han
+Author-email: Bolun.Han@outlook.com
+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.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# PyEventEngine
+
+python native event engine
+
+# Install
+
+```shell
+pip install git+https://github.com/BolunHan/PyEventEngine.git
+```
+
+or
+
+```shell
+pip install PyEventEngine
+```
+
+# Use
+
+## basic usage
+
+```python
+# init event engine
+import time
+from event_engine import EventEngine, Topic
+
+EVENT_ENGINE = EventEngine()
+EVENT_ENGINE.start()
+
+
+# register handler
+def test_handler(msg, **kwargs):
+    print(msg)
+
+
+EVENT_ENGINE.register_handler(topic=Topic('SimpleTopic'), handler=test_handler)
+
+# publish message
+EVENT_ENGINE.put(topic=Topic('SimpleTopic'), msg='topic called')
+time.sleep(1)
+EVENT_ENGINE.stop()
+```
+
+## regular topic
+
+```python
+# init event engine
+import time
+from event_engine import EventEngine, Topic, RegularTopic
+
+EVENT_ENGINE = EventEngine()
+EVENT_ENGINE.start()
+
+
+# register handler
+def test_handler(msg, **kwargs):
+    print(msg)
+
+
+EVENT_ENGINE.register_handler(topic=RegularTopic('RegularTopic.*'), handler=test_handler)
+
+# publish message
+EVENT_ENGINE.put(topic=Topic('RegularTopic.ChildTopic0'), msg='topic called')
+time.sleep(1)
+EVENT_ENGINE.stop()
+```
+
+## timer topic
+
+```python
+# init event engine
+import time
+from event_engine import EventEngine, Topic, RegularTopic
+
+EVENT_ENGINE = EventEngine()
+EVENT_ENGINE.start()
+
+
+# register handler
+def test_handler(**kwargs):
+    print(kwargs)
+
+
+topic = EVENT_ENGINE.get_timer(interval=1)
+EVENT_ENGINE.register_handler(topic=topic, handler=test_handler)
+
+# publish message
+time.sleep(5)
+EVENT_ENGINE.stop()
+```
+
+See more advanced usage at .Demo

{PyEventEngine-0.3.0.post5 → pyeventengine-0.3.2}/PyEventEngine.egg-info/SOURCES.txt

@@ -7,8 +7,6 @@ PyEventEngine.egg-info/SOURCES.txt
 PyEventEngine.egg-info/dependency_links.txt
 PyEventEngine.egg-info/top_level.txt
 event_engine/__init__.py
-event_engine/cpp/topic_api.cpp
-event_engine/cpp/topic_api.cpp
 event_engine/native/__init__.py
 event_engine/native/_event.py
 event_engine/native/_topic.py

pyeventengine-0.3.2/event_engine/__init__.py

@@ -0,0 +1,3 @@
+__version__ = '0.3.2'
+
+from .native import *

{PyEventEngine-0.3.0.post5 → pyeventengine-0.3.2}/event_engine/native/_event.py

@@ -139,7 +139,7 @@ class EventEngineBase(object):
         self._get_lock = Semaphore(0)
         self._deque: deque[EventDict] = deque(maxlen=buffer_size if buffer_size else None)
         self._active: bool = False
-        self._engine: Thread = Thread(target=self._run, name='EventEngine')
+        self._engine: Thread = None
         self._event_hooks: dict[Topic, EventHook] = {}
 
         if buffer_size and buffer_size < 8:
@@ -184,6 +184,7 @@ class EventEngineBase(object):
             return
 
         self._active = True
+        self._engine = Thread(target=self._run, name='EventEngine')
         self._engine.start()
 
     def stop(self) -> None:
@@ -198,6 +199,18 @@ class EventEngineBase(object):
         self._get_lock.release()
         self._engine.join()
 
+    def clear(self) -> None:
+        if self._active:
+            self.logger.error('EventEngine must be stopped before cleared!')
+            return
+
+        self._event_hooks.clear()
+        self._deque.clear()
+
+        if self._buffer_size:
+            self._put_lock._value = self._buffer_size
+            self._get_lock._value = 0
+
     def put(self, topic: str | Topic, block: bool = True, timeout: float = None, *args, **kwargs):
         """
         fast way to put an event, kwargs MUST NOT contain "topic", "block" and "timeout" keywords
@@ -384,3 +397,9 @@ class EventEngine(EventEngineBase):
 
         for timer in self.timer.values():
             timer.join()
+
+    def clear(self) -> None:
+        for t in self.timer.values():
+            t.join(timeout=0)
+
+        self.timer.clear()

{PyEventEngine-0.3.0.post5 → pyeventengine-0.3.2}/event_engine/native/_topic.py

@@ -116,7 +116,7 @@ class PatternTopic(Topic):
         pattern_parts = pattern.split('.')
 
         # Check if the number of parts in result and pattern are the same
-        if len(result_parts) != len(pattern_parts):
+        if len(result_parts) < len(pattern_parts):
             raise cls.NotMatchError(f'Target {target} not match with pattern {pattern}.')
 
         # Generate the mapping dictionary

{PyEventEngine-0.3.0.post5 → pyeventengine-0.3.2}/event_engine/native/_topic_c.py

@@ -1,94 +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
+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.2/setup.cfg

@@ -0,0 +1,22 @@
+[metadata]
+name = PyEventEngine
+version = attr: event_engine.__init__.__version__
+author = Bolun.Han
+author_email = Bolun.Han@outlook.com
+description = Basic event engine
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/BolunHan/PyEventEngine.git
+license = MIT
+classifiers = 
+	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
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

{PyEventEngine-0.3.0.post5 → pyeventengine-0.3.2}/setup.py

@@ -44,10 +44,23 @@ setuptools.setup(
         "Programming Language :: Python :: 3.12",
         "Operating System :: OS Independent",
     ],
-    python_requires='>=3.8',
+    python_requires='>=3.12',
     license='MIT',
     install_requires=[],
-    ext_modules=[
-        setuptools.extension.Extension(r'event_engine.topic_api', sources=[r'event_engine/cpp/topic_api.cpp'], include_dirs=[], language='c++', optional=True),
-    ],
+    # ext_modules=[
+    #     setuptools.extension.Extension(r'event_engine.topic_api', sources=[r'event_engine/cpp/topic_api.cpp'], include_dirs=[], language='c++', optional=True),
+    #     setuptools.extension.Extension(r'event_engine.event_api', sources=[r'event_engine/cpp/event_api.cpp'], include_dirs=[], language='c++', optional=True)
+    # ],
+    command_options={
+        'nuitka': {
+            # boolean option, e.g. if you cared for C compilation commands
+            '--show-scons': ("setup.py", True),
+            # options without value, e.g. enforce using Clang
+            '--clang': ("setup.py", None),
+            # options with single values, e.g. enable a plugin of Nuitka
+            # '--enable-plugin': ("setup.py", "pyside2"),
+            # options with several values, e.g. avoiding including modules
+            # '--nofollow-import-to': ("setup.py", ["*.tests", "*.distutils"]),
+        }
+    }
 )

PyEventEngine-0.3.0.post5/event_engine/__init__.py

@@ -1,3 +0,0 @@
-__version__ = '0.3.0.post5'
-
-from .native import *

PyEventEngine-0.3.0.post5/event_engine/cpp/topic_api.cpp

@@ -1,288 +0,0 @@
-#include <iostream>
-#include <regex>
-#include <string>
-#include <unordered_map>
-#include <utility>
-#include <vector>
-
-extern "C" {
-#include <stdlib.h>
-}
-
-class Topic : public std::unordered_map<std::string, std::string> {
-public:
-    class Error : public std::exception {
-    public:
-        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(std::string topic) : _value(std::move(topic)) {}
-
-    std::string value() const { return _value; }
-
-    virtual Topic match(const std::string &topic) const {
-        if (_value == topic) {
-            return Topic(topic);
-        } else {
-            return Topic("");
-        }
-    }
-
-    std::string _value;
-};
-
-class RegularTopic : public Topic {
-public:
-    explicit RegularTopic(const std::string &pattern) : Topic(pattern) {}
-
-    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;
-        } else {
-            return Topic("");
-        }
-    }
-};
-
-class PatternTopic : public Topic {
-public:
-    explicit PatternTopic(const std::string &pattern) : Topic(pattern) {}
-
-    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) {
-            auto it = mapping.find(content);
-            if (it != mapping.end()) {
-                std::string replacement = it->second;
-                std::string searchStr = "{" + content + "}";
-                size_t startPos = result.find(searchStr);
-                while (startPos != std::string::npos) {
-                    result.replace(startPos, searchStr.length(), replacement);
-                    startPos = result.find(searchStr, startPos + replacement.length());
-                }
-            }
-        }
-
-        return Topic(result);
-    }
-
-    std::vector<std::string> keys() const {
-        std::vector<std::string> contentVec;
-        std::vector<std::string> keys;
-
-        size_t startPos = _value.find('{');
-        size_t endPos;
-
-        while (startPos != std::string::npos) {
-            endPos = _value.find('}', startPos + 1);
-            if (endPos == std::string::npos)
-                break;
-
-            std::string content = _value.substr(startPos + 1, endPos - startPos - 1);
-            keys.push_back(content);
-
-            startPos = _value.find('{', endPos + 1);
-        }
-
-        return keys;
-    }
-
-    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) {
-        std::unordered_map<std::string, std::string> dictionary;
-
-        std::vector<std::string> resultParts;
-        std::vector<std::string> patternParts;
-
-        // Split the result string by '.'
-        size_t startPos = 0;
-        size_t dotPos = target.find('.');
-        while (dotPos != std::string::npos) {
-            std::string part = target.substr(startPos, dotPos - startPos);
-            resultParts.push_back(part);
-            startPos = dotPos + 1;
-            dotPos = target.find('.', startPos);
-        }
-        std::string lastPart = target.substr(startPos);
-        resultParts.push_back(lastPart);
-
-        // Split the pattern string by '.'
-        startPos = 0;
-        dotPos = pattern.find('.');
-        while (dotPos != std::string::npos) {
-            std::string part = pattern.substr(startPos, dotPos - startPos);
-            patternParts.push_back(part);
-            startPos = dotPos + 1;
-            dotPos = pattern.find('.', startPos);
-        }
-        lastPart = pattern.substr(startPos);
-        patternParts.push_back(lastPart);
-
-        // Check if the number of parts in result and pattern are the same
-        if (resultParts.size() != patternParts.size()) {
-            return dictionary;
-        }
-
-        // Generate the mapping dictionary
-        size_t numParts = resultParts.size();
-        for (size_t i = 0; i < numParts; ++i) {
-            std::string resultPart = resultParts[i];
-            std::string patternPart = patternParts[i];
-
-            if (patternPart.front() == '{' && patternPart.back() == '}') {
-                std::string content = patternPart.substr(1, patternPart.length() - 2);
-                dictionary[content] = resultPart;
-            } else {
-                if (resultPart != patternPart) {
-                    dictionary.clear();
-                    return dictionary;
-                }
-            }
-        }
-        return dictionary;
-    }
-};
-
-extern "C" {
-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';
-}
-
-const char *get_topic_value_no_buffer(const Topic *topic) {
-    return topic->_value.c_str();
-}
-
-void delete_topic(Topic *topic) {
-    delete 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);
-}
-
-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);
-}
-
-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());
-}
-
-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;
-}
-
-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);
-
-    std::unordered_map<std::string, std::string> mapping = PatternTopic::extract_mapping(target_str, pattern_str);
-
-    // Populate the keys and values vectors
-    for (const auto &entry: mapping) {
-        keys->push_back(entry.first);
-        values->push_back(entry.second);
-    }
-}
-
-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 "";
-}
-
-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() {
-    Topic topic("TickData.002410.SZ.Realtime");
-    std::cout << topic.value() << std::endl;
-
-    RegularTopic regularTopic("TickData.(.+).((SZ)|(SH)).((Realtime)|(History))");
-    Topic match1 = regularTopic.match("TickData.1234.SZ.Realtime");
-    Topic match2 = regularTopic.match("OtherData.5678.SH.History");
-    std::cout << match1.value() << std::endl;
-    std::cout << match2.value() << std::endl;
-
-    PatternTopic patternTopic("TickData.{symbol}.{market}.{flag}");
-    for (const std::string &i: patternTopic.keys())
-        std::cout << i << std::endl;
-
-    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) {
-        std::cout << entry.first << " : " << entry.second << std::endl;
-    }
-
-    std::cout << "topic: " << match4.value() << std::endl;
-    for (const auto &entry: match4) {
-        std::cout << entry.first << " : " << entry.second << std::endl;
-    }
-
-    return 0;
-}

PyEventEngine-0.3.0.post5/setup.cfg

@@ -1,7 +0,0 @@
-[metadata]
-description-file = README.md
-
-[egg_info]
-tag_build = 
-tag_date = 0
-