update

Author: bierdok

setup.py

@@ -2,7 +2,7 @@
 
 setup(
     name='talkops',
-    version='1.1.1',
+    version='1.2.0',
     author='PicoUX',
     description="TalkOps SDK",
     long_description=open('README.md',encoding='utf-8').read(),
@@ -16,7 +16,7 @@
         'Issues': 'https://github.com/talkops/sdk-python/issues',
         'Source': 'https://github.com/talkops/sdk-python',
     },
-    install_requires=['jinja2', 'requests', 'sseclient'],
+    install_requires=['aiosseclient', 'jinja2', 'requests'],
     keywords=['sdk'],
     classifiers=[
       "Programming Language :: Python :: 3",

talkops/extension.py

@@ -11,6 +11,7 @@
 import json
 import base64
 import os
+import time
 
 class Extension:
     def __init__(self, token=None):
@@ -30,12 +31,15 @@ def __init__(self, token=None):
         self._started = False
         self._token = token or os.environ.get('TALKOPS_TOKEN')
         self._website = None
+        self._setup()
 
-    async def _setup(self):
+    def _setup(self):
         if self._started:
             return
         self._started = True
+        print("test1")
         await asyncio.sleep(0.5)
+        print("test2")
         if self._token:
             mercure = json.loads(base64.b64decode(self._token).decode())
             self._publisher = Publisher(
@@ -47,7 +51,7 @@ async def _setup(self):
                     'installationSteps': self._installation_steps,
                     'instructions': self._instructions,
                     'name': self._name,
-                    'parameters': self._parameters,
+                    'parameters': [p.to_json() for p in self._parameters],
                     'sdk': {
                         'name': 'python',
                         'version': version('talkops'),
@@ -89,9 +93,11 @@ async def _setup(self):
                     'website': self._website,
                 }
             )
+        while True:
+            await asyncio.sleep(1)
 
     def start(self):
-        asyncio.run(self._setup())
+        self._setup()
         return self
 
     def on(self, event_type, callback):

talkops/parameter.py

@@ -25,8 +25,8 @@ def __init__(self, name):
             raise ValueError('name expected uppercase letters, numbers, and underscores.')
         self._name = name
         self._description = None
-        self._value = None
-        self._default_value = None
+        self._value = ''
+        self._default_value = ''
         self._available_values = []
         self._possible_values = []
         self._optional = False
@@ -69,14 +69,14 @@ def value(self):
         return os.environ.get(self._name) or self._value or self._default_value
 
     def set_value(self, value):
-        if value is not None and (not isinstance(value, str) or not value.strip()):
-            raise ValueError('value must be a non-empty string.')
+        if not isinstance(value, str):
+            raise ValueError('value must be a string.')
         self._value = value
         return self
 
     @property
     def has_value(self):
-        return self.value is not None and self.value != ''
+        return self.value != ''
 
     def set_available_values(self, available_values):
         if not isinstance(available_values, list) or not available_values:

talkops/subscriber.py

@@ -3,57 +3,62 @@
 from urllib.parse import quote
 import asyncio
 import json
-import requests
 import sys
-import time
+import nest_asyncio
 
 class Subscriber:
     def __init__(self, use_config):
         self._use_config = use_config
         self._subscribe()
 
     def _subscribe(self):
+        nest_asyncio.apply()
         config = self._use_config()
         mercure = config['mercure']
-        try:
-            messages = SSEClient(
-                f"{mercure['url']}?topic={quote(mercure['subscriber']['topic'])}",
-                headers={
-                    'Authorization': f"Bearer {mercure['subscriber']['token']}",
-                }
-            )
-            for message in messages:
-                self._on_event(json.loads(message.data))
-        except Exception as e:
-            print(e)
+        messages = SSEClient(
+            f"{mercure['url']}?topic={quote(mercure['subscriber']['topic'])}",
+            headers={
+                'Authorization': f"Bearer {mercure['subscriber']['token']}"
+            }
+        )
+        for message in messages:
+            try:
+                event = json.loads(message.data)
+            except json.JSONDecodeError as e:
+                print(f"Failed to decode JSON: {e}", file=sys.stderr)
+                continue
+            self._on_event(event)
 
     def _on_event(self, event):
         config = self._use_config()
         if event['type'] == 'ping':
             config['publisher'].on_ping()
             return
         if event['type'] == 'function_call':
-            for fn in config['functions']:
-                if fn.__name__ != event['name']:
+            for function in config['functions']:
+                if function.__name__ != event['name']:
                     continue
                 arguments_list = [
                     event['args'].get(name) or event['defaultArgs'].get(name)
-                    for name in fn.__code__.co_varnames
+                    for name in function.__code__.co_varnames
                 ]
-                output = fn(*arguments_list)
+                output = function(*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)
+            print(f'Function {function.__name__} not found.', file=sys.stderr)
             return
         if event['type'] == 'boot':
             for name, value in event['parameters'].items():
                 for parameter in config['parameters']:
                     if parameter.name != name:
                         continue
-                    parameter.set_value(value)
+                    if isinstance(value, str):
+                        parameter.set_value(value)
+                    else:
+                        parameter.set_value("")
             ready = True
             for parameter in config['parameters']:
                 if parameter.is_optional:
@@ -69,8 +74,4 @@ def _on_event(self, event):
             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 files('talkops.data').joinpath('event-types.json').open('r', encoding='utf-8') as f:
-            return json.load(f)
+                asyncio.run(output)