Fix major issues

Author: bierdok

pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "talkops"
+version = "1.0.0"
+description = "TalkOps SDK"
+authors = [{ name = "PicoUX" }]
+license = "MIT"
+requires-python = ">=3.7"
+dependencies = [
+    "jinja2>=3.1.6",
+    "requests>=2.32.3",
+    "sseclient-py>=1.8.0"
+]

setup.py

@@ -1,19 +1,36 @@
-import os
-import json
-import base64
 from urllib.parse import urlparse
 from .publisher import Publisher
 from .subscriber import Subscriber
 from .parameter import Parameter
 from .readme import Readme
 from .manifest import Manifest
+import asyncio
+import json
+import base64
+import os
 import pkg_resources
 
 class Extension:
     def __init__(self, token=None):
-        token = token or os.environ.get('TALKOPS_TOKEN')
-        if token:
-            mercure = json.loads(base64.b64decode(token).decode())
+        self._callbacks = {}
+        self._category = None
+        self._demo = False
+        self._features = []
+        self._functions = []
+        self._function_schemas = []
+        self._icon = None
+        self._installation_steps = []
+        self._instructions = None
+        self._name = None
+        self._parameters = []
+        self._software_version = None
+        self._token = token or os.environ.get('TALKOPS_TOKEN')
+        self._website = None
+
+    async def _setup(self):
+        await asyncio.sleep(0.5)
+        if self._token:
+            mercure = json.loads(base64.b64decode(self._token).decode())
             self._publisher = Publisher(
                 lambda: {'mercure': mercure},
                 lambda: {
@@ -43,7 +60,7 @@ def __init__(self, token=None):
                 }
             )
 
-        if os.environ.get('NODE_ENV') == 'development':
+        if os.environ.get('ENV') == 'development':
             Readme(
                 lambda: {
                     'features': self._features,
@@ -59,26 +76,16 @@ def __init__(self, token=None):
                     'name': self._name,
                     'sdk': {
                         'name': 'python',
-                        'version': '2.14.1',
+                        'version': pkg_resources.get_distribution('talkops').version,
                     },
                     'softwareVersion': self._software_version,
                     'website': self._website,
                 }
             )
 
-        self._callbacks = {}
-        self._category = None
-        self._demo = False
-        self._features = []
-        self._functions = []
-        self._function_schemas = []
-        self._icon = None
-        self._installation_steps = []
-        self._instructions = None
-        self._name = None
-        self._parameters = []
-        self._software_version = None
-        self._website = None
+    def start(self):
+        asyncio.run(self._setup())
+        return self
 
     def on(self, event_type, callback):
         if event_type not in self._get_event_types():
@@ -155,37 +162,55 @@ def set_instructions(self, instructions):
         return self
 
     def set_function_schemas(self, function_schemas):
-        if not isinstance(function_schemas, list):
-            raise ValueError('function_schemas must be an array.')
+        if (
+            not isinstance(function_schemas, list) or
+            not all(isinstance(schema, dict) and schema is not None for schema in function_schemas)
+        ):
+            raise ValueError('functionSchemas must be an array of non-null objects.')
         self._function_schemas = function_schemas
         return self
 
     def set_functions(self, functions):
-        if not isinstance(functions, list):
-            raise ValueError('functions must be an array.')
+        if (
+            not isinstance(functions, list) or
+            not all(callable(fn) for fn in functions) or
+            not all(hasattr(fn, '__name__') and fn.__name__.strip() for fn in functions)
+        ):
+            raise ValueError('functions must be an array of named functions.')
         self._functions = functions
         return self
 
     def enable_alarm(self):
-        self._publisher.enable_alarm()
+        self._publisher.publish_event({'type': 'alarm'})
         return self
 
     def send_medias(self, medias):
-        self._publisher.send_medias(medias)
+        if not isinstance(medias, list):
+            medias = [medias]
+        if not all(isinstance(media, Media) for media in medias):
+            raise ValueError("medias must be a list of Media instances.")
+        self._publisher.publish_event({
+            'type': 'medias',
+            'medias': [media.to_json() for media in medias]
+        })
         return self
 
     def send_message(self, text):
-        self._publisher.send_message(text)
+        if not isinstance(text, str) or not text.strip():
+            raise ValueError('text must be a non-empty string.')
+        self._publisher.publish_event({ 'type': 'message', 'text': text })
         return self
 
     def send_notification(self, text):
-        self._publisher.send_notification(text)
+        if not isinstance(text, str) or not text.strip():
+            raise ValueError('text must be a non-empty string.')
+        self._publisher.publish_event({ 'type': 'notification', 'text': text })
         return self
 
-    def _get_event_types(self):
-        with open(os.path.join(os.path.dirname(__file__), 'event_types.json'), 'r') as f:
-            return json.load(f)
-
     def _get_categories(self):
         with open(os.path.join(os.path.dirname(__file__), 'categories.json'), 'r') as f:
             return json.load(f)
+
+    def _get_event_types(self):
+        with open(os.path.join(os.path.dirname(__file__), 'event-types.json'), 'r') as f:
+            return json.load(f)

src/talkops/__init__.py src/talkops/__init__ .pysrc/talkops/__init__.py renamed to src/talkops/__init__ .py

@@ -2,11 +2,10 @@
 import json
 
 class Manifest:
-    def __init__(self, get_config):
-        self._get_config = get_config
-        time.sleep(0.5)
+    def __init__(self, use_extension):
+        self._use_extension = use_extension
         self._generate()
 
     def _generate(self):
         with open('/app/manifest.json', 'w') as f:
-            json.dump(self._get_config(), f, indent=2)
+            json.dump(self._use_extension(), f, indent=2)

src/talkops/extension.py

@@ -11,8 +11,8 @@ def __init__(self, use_config, use_state):
         self._use_state = use_state
         self._last_event_state = None
         self._last_ping_at = None
-        threading.Timer(0.9, lambda: self._publish_data(json.dumps({'type': 'init'}))).start()
-        threading.Timer(1.0, self._publish_state).start()
+        threading.Timer(0.4, lambda: self._publish_data(json.dumps({'type': 'init'}))).start()
+        threading.Timer(0.5, self._publish_state).start()
         self._original_stdout_write = sys.stdout.write
         self._original_stderr_write = sys.stderr.write
         def stdout_wrapper(chunk):
@@ -23,30 +23,31 @@ def stdout_wrapper(chunk):
             return self._original_stdout_write(chunk)
 
         def stderr_wrapper(chunk):
-            self.publish_event({
-                'type': 'stderr',
-                'data': chunk.strip()
-            })
+            if b"KeyboardInterrupt" not in chunk:
+                self.publish_event({
+                    'type': 'stderr',
+                    'data': chunk.strip()
+                })
             return self._original_stderr_write(chunk)
 
         sys.stdout.write = stdout_wrapper
         sys.stderr.write = stderr_wrapper
 
-    async def publish_state(self):
+    def publish_state(self):
         event = {'type': 'state', 'state': self._use_state()}
         self._last_event_state = json.dumps(event)
-        await self.publish_event(event)
+        self.publish_event(event)
 
     def on_ping(self):
         self._last_ping_at = time.time() * 1000
         self.publish_event({'type': 'pong'})
 
-    async def publish_event(self, event):
+    def publish_event(self, event):
         if self._last_ping_at and self._last_ping_at < (time.time() * 1000 - 6000):
             return
-        await self._publish_data(json.dumps(event))
+        self._publish_data(json.dumps(event))
 
-    async def _publish_data(self, data):
+    def _publish_data(self, data):
         config = self._use_config()
         response = requests.post(
             config['mercure']['url'],
@@ -61,11 +62,11 @@ async def _publish_data(self, data):
         )
         response.raise_for_status()
 
-    async def _publish_state(self):
+    def _publish_state(self):
         event = {'type': 'state', 'state': self._use_state()}
         last_event_state = json.dumps(event)
         if self._last_event_state != last_event_state:
-            await self.publish_event(event)
+            self.publish_event(event)
             self._last_event_state = last_event_state
         threading.Timer(1.0, self._publish_state).start()
 

src/talkops/manifest.py

@@ -5,7 +5,6 @@
 class Readme:
     def __init__(self, getter):
         self._getter = getter
-        time.sleep(0.5)
         self._generate()
 
     def _generate(self):

src/talkops/publisher.py

@@ -1,10 +1,13 @@
+import asyncio
 import json
+import os
+import re
+import requests
 import sseclient
+import sys
 import threading
-import requests
-import re
+import time
 from urllib.parse import quote
-import os
 
 class Subscriber:
     def __init__(self, use_config):
@@ -51,12 +54,11 @@ def _subscribe(self):
                     self._on_event(json.loads(event.data))
 
             except Exception as e:
-                print(f"Error in subscriber: {e}")
+                print(f"Error in subscriber: {e}", file=sys.stderr)
                 if self._running:
-                    import time
                     time.sleep(5)
 
-    async def _on_event(self, event):
+    def _on_event(self, event):
         config = self._use_config()
         if event['type'] == 'ping':
             config['publisher'].on_ping()
@@ -65,17 +67,18 @@ async def _on_event(self, event):
             for fn in config['functions']:
                 if fn.__name__ != event['name']:
                     continue
-                match = re.match(r'\(([^)]*)\)', fn.__code__.co_varnames[:fn.__code__.co_argcount])
-                arguments_list = []
-                if match:
-                    param_names = [p.strip() for p in match.group(1).split(',')]
-                    arguments_list = [
-                        event['args'].get(name) or event['defaultArgs'].get(name)
-                        for name in param_names
-                    ]
-                event['output'] = await fn(*arguments_list)
+                arguments_list = [
+                    event['args'].get(name) or event['defaultArgs'].get(name)
+                    for name in fn.__code__.co_varnames
+                ]
+                output = fn(*arguments_list)
+                if asyncio.iscoroutine(output):
+                    output = asyncio.run(output)
+                event['output'] = output
                 config['publisher'].publish_event(event)
                 return
+            print(f'Function {fn.__name__} not found.', file=sys.stderr)
+            return
         if event['type'] == 'boot':
             for name, value in event['parameters'].items():
                 for parameter in config['parameters']:
@@ -94,13 +97,11 @@ async def _on_event(self, event):
                 return
         if event['type'] in self._get_event_types() and event['type'] in config['callbacks']:
             callback = config['callbacks'][event['type']]
-            match = re.match(r'\(([^)]*)\)', callback.__code__.co_varnames[:callback.__code__.co_argcount])
-            arguments_list = []
-            if match:
-                param_names = [p.strip() for p in match.group(1).split(',')]
-                arguments_list = [event['args'].get(name) for name in param_names]
-            await callback(*arguments_list)
+            arguments_list = [event['args'].get(name) for name in callback.__code__.co_varnames]
+            output = callback(*arguments_list)
+            if asyncio.iscoroutine(output):
+                output = asyncio.run(output)
 
     def _get_event_types(self):
-        with open(os.path.join(os.path.dirname(__file__), 'event_types.json'), 'r') as f:
+        with open(os.path.join(os.path.dirname(__file__), 'event-types.json'), 'r') as f:
             return json.load(f)