triggerware 0.1.0__tar.gz → 0.1.2__tar.gz

{triggerware-0.1.0 → triggerware-0.1.2}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.3
 Name: triggerware
-Version: 0.1.0
+Version: 0.1.2
 Summary: 
 Author: godofavacyn
 Author-email: godofavacyn <aidenmeyer@mailbox.org>
-Requires-Dist: jayson-rpc
+Requires-Dist: jayson-rpc[websockets]
 Requires-Dist: sphinx
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{triggerware-0.1.0 → triggerware-0.1.2}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "triggerware"
-version = "0.1.0"
+version = "0.1.2"
 description = ""
 readme = "README.md"
 requires-python = ">=3.11"
 authors = [{name = "godofavacyn", email = "aidenmeyer@mailbox.org"}]
 dependencies = [
-   "jayson-rpc",
+   "jayson-rpc[websockets]",
    "sphinx"
 ]
 

{triggerware-0.1.0 → triggerware-0.1.2}/src/triggerware/_result_set.py

@@ -73,7 +73,7 @@ class ResultSet[T](TriggerwareObject, ResourceRestricted):
         for _ in range(n):
             try:
                 items.append(await anext(self))
-            except StopIteration:
+            except StopAsyncIteration:
                 break
         return items
 

{triggerware-0.1.0 → triggerware-0.1.2}/src/triggerware/_triggerware_client.py

@@ -48,7 +48,8 @@ class TriggerwareClient:
         Args:
             uri: The WebSocket URI to connect to.
         """
-        uri = "ws://tw-instance-load-balancer-194323221.us-east-2.elb.amazonaws.com"
+        # uri = "ws://tw-instance-load-balancer-194323221.us-east-2.elb.amazonaws.com"
+        uri = "wss://instances.triggerware.com"
         json_rpc = await JsonRpcWebSocketConnection.connect(
             uri,
             headers={
@@ -95,10 +96,34 @@ class TriggerwareClient:
         return await View(self, query).validate()
 
     async def close(self):
+        """Closes the connection to the server."""
+        await self.json_rpc.close()
+
+    async def activate_connector(self, name: str, json_data: dict | None = None):
+        """Activate a connector on the server.
+
+        Args:
+            name: The name of the connector to activate.
+            json_data: Optional data to pass to the connector upon activation.
+        """
+        await self.json_rpc.call("activate_connector", {"name": name, "json_data": json_data})
+
+    async def deactivate_connector(self, name: str):
+        """Deactivate a connector on the server.
+
+        Args:
+            name: The name of the connector to deactivate.
         """
-        Closes the connection to the server.
+        await self.json_rpc.call("deactivate_connector", {"name": name})
+
+    async def list_active_connectors(self) -> list[str]:
+        """Query the server for which connectors are currently activated.
+
+        Returns:
+            list[str]: The names of all currently active connectors.
         """
-        await self.json_rpc.close()
+        result = await self.json_rpc.call("list-active-connectors", {})
+        return result["connectors"]
 
     @property
     def is_closed(self) -> bool:

triggerware-0.1.0/src/triggerware/_external_connector.old

@@ -1,130 +0,0 @@
-from typing import Any, TYPE_CHECKING, Callable
-import threading
-import inspect
-import importlib
-
-if TYPE_CHECKING:
-    import triggerware as tw
-
-sql_types = {
-    "str": "casesensitive",
-    "int": "int",
-}
-
-
-class ConnectorManager:
-    def __init__(
-        self,
-        tw_client: "tw.TriggerwareClient",
-        external_address: str,
-        external_port: int,
-    ) -> None:
-        self._client: "tw.TriggerwareClient" = tw_client
-        self._address = external_address
-        self._port = external_port
-        self._lock = threading.Lock()
-        self._conn_names: set[str] = set()
-        self._gen_functions: dict[str, Callable[..., Any]] = {}
-        threading.Thread(target=self._run, daemon=True).start()
-
-    def create_schema(self, schema: str):
-        params = {"name": schema}
-        _ = self._client.json_rpc.call("create-sql-schema", params)
-
-    def add_connector(self, connector: "Connector"):
-        generators: list[dict] = []
-        with self._lock:
-            if connector.name in self._conn_names:
-                raise ValueError(
-                    f"Connector with name {connector.name} already exists."
-                )
-            self._conn_names.add(connector.name)
-            for gen_name, generator in connector.generators.items():
-                generators.append(
-                    {
-                        "name": gen_name,
-                        "cost": generator.cost,
-                        "inputs": generator.inputs,
-                    }
-                )
-                self._gen_functions[gen_name] = generator.func
-        params = {
-            "columns": connector.columns,
-            "generator": generators,
-            "host": self._address,
-            "port": self._port,
-            "schema": connector.schema,
-            "name": connector.name,
-        }
-        _ = self._client.json_rpc.call("define-external-jsonrpc-table", params)
-
-    def _run(self):
-        # for conn in TcpStreamConnection.serve(self._address, self._port):
-        async def handler(conn: JsonRpcStreamConnection):
-            @conn.method()
-            def generate(
-                inputs: list[Any] = [],
-                name: str = "",
-                limit=None,
-                notify_timelimit=None,
-            ):
-                with self._lock:
-                    if name in self._gen_functions:
-                        return self._gen_functions[name](*inputs)
-                    else:
-                        raise ValueError(f"'{name}' not found in connectors.")
-            await conn.wait_closed()
-
-    async def close(self):
-        with self._lock:
-            await self._client.close()
-
-    @property
-    def is_closed(self) -> bool:
-        with self._lock:
-            return self._client.is_closed
-
-
-class Generator:
-    def __init__(
-        self, name: str, func: Callable[..., Any], inputs: list[str], cost: int
-    ):
-        self.name = name
-        self.func = func
-        self.inputs = inputs
-        self.cost = cost
-
-
-class Connector:
-    def __init__(
-        self,
-        *,
-        name: str,
-        columns: list[tuple[str, str | type]],
-        schema: str = "DEMO",
-    ):
-        self.name = name
-        self.schema = schema
-        try:
-            type_name = lambda ty: (
-                sql_types[ty.__name__] if isinstance(ty, type) else ty
-            )
-            self.columns = [[name, type_name(ty)] for name, ty in columns]
-        except KeyError as e:
-            raise TypeError(f"Unsupported type in columns: {e}")
-        self.generators: dict[str, Generator] = {}
-        self.generator_count = 0
-
-    def generate(self, cost: int = 1):
-        def decorator(func: Callable[..., Any]):
-            gen_name = f"{self.name}__{self.generator_count}"
-            inputs = [
-                param.name for param in inspect.signature(func).parameters.values()
-            ]
-            self.generators[gen_name] = Generator(gen_name, func, inputs, cost)
-            self.generator_count += 1
-            return func
-
-        return decorator
-
-__all__ = ["ConnectorManager", "Connector", "Generator"]