joulectl 0.1.3__tar.gz

joulectl-0.1.3/AUTHORS

@@ -0,0 +1,7 @@
+# A list of people who have contributed to twine in order of their first
+#   contribution.
+#
+#   Uses the format of ``Name <email@domain.tld> (url)`` with the ``(url)``
+#   being optional.
+
+Lyndon Adams <lyndon.adams@fractalworks.io> (https://fractalworks.io)

joulectl-0.1.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Fractalworks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

joulectl-0.1.3/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.3
+Name: joulectl
+Version: 0.1.3
+Summary: Joule CLI tool to manage Joule transports, streams and use cases
+License: MIT
+Keywords: joule,streaming
+Author: Lyndon Adams
+Author-email: lyndon.adams@fractalworks.io
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Requires-Dist: click (>=8.1.8,<9.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: tabulate (>=0.9.0,<1.0.0)
+Project-URL: Documentation, https://docs.fractalworks.io/joule
+Project-URL: Homepage, https://https://getjoule.io/
+Description-Content-Type: text/markdown
+
+## Python Joule Tools
+Joule is a low-code real-time stream processing engine.
+
+Joule currently supports wide range of data sources (such as Kafka, MQTT, RabbitMQ, InfuxDB, Minio S3 etc), 
+machine learning inference, custom analytics, event windows 
+
+## Why Should I Use This?
+When you need to deploy and manage use cases within the Joule processing environment.
+
+## Features
+- Deploy transports, streams and use cases.
+- Inspect all deployed specifications for transports, streams and use cases.
+- List all deployed transports, streams and use cases.
+- Undeploy transports, streams and use cases.
+- Use case management to pause and resume processing.
+
+## Installation
+```bash
+$ pip install joulectl
+```
+
+## Using joulectl
+The tool provides a number of commands to 
+support the deployment and management of Joule use case configurations
+
+### Setup tool
+First create a configuration file
+```bash
+joulectl config create
+```
+
+Now update the Joule host which you would like to connect too.
+The default is ```localhost:9080```
+```bash
+joulectl config update --host 192.168.86.48:9080
+```
+
+You are now ready to deploy and manage joule remotely.
+
+## Commands
+List of available commands
+
+### deploy
+Deploy command for transports, streams and use cases.
+
+#### Subcommands
+- ```stream```     Deploy a stream
+- ```transport```  Deploy a transport
+- ```usecase```    Deploy a use case
+
+### list
+List deployed transports, streams and use cases.
+
+#### Subcommands
+- ```transports``` List transport by provided type
+- ```streams```   List registered streams
+- ```usecases```  List use cases
+
+### inspect
+Display deployed specification for transports, streams and use caase.
+
+#### Subcommands
+- ```stream```     Get a stream specification
+- ```transport```  Get a transport specification
+- ```usecase```    Get a use case specification
+
+### usecase
+Management command for use cases.
+
+#### Subcommands
+- ```pause```   Pause use case processing
+- ```resume```  Resume use case processing
+
+### undeploy
+Use case management command for transports, streams and use cases.
+
+#### Subcommands
+- ```stream```     Undeploy stream
+- ```transport```  Undeploy transport by provided type
+- ```usecase```    Undeploy use case
+
+### config
+Configure tool setting.
+
+#### Subcommands
+- ```create```  Create a new configuration file.
+- ```show```    Show configuration setting.
+- ```update```  Update configuration setting.
+
+## Resources
+- Discord Joule [server](https://discord.com/channels/1080521605786116196/1080521606247493724)
+- User and developer [documentation](https://docs.fractalworks.io/joule) 
+- Joule [website](https://getjoule.io) 
+
+## License
+Joule Tools are released under an MIT License.

joulectl-0.1.3/README.md

@@ -0,0 +1,96 @@
+## Python Joule Tools
+Joule is a low-code real-time stream processing engine.
+
+Joule currently supports wide range of data sources (such as Kafka, MQTT, RabbitMQ, InfuxDB, Minio S3 etc), 
+machine learning inference, custom analytics, event windows 
+
+## Why Should I Use This?
+When you need to deploy and manage use cases within the Joule processing environment.
+
+## Features
+- Deploy transports, streams and use cases.
+- Inspect all deployed specifications for transports, streams and use cases.
+- List all deployed transports, streams and use cases.
+- Undeploy transports, streams and use cases.
+- Use case management to pause and resume processing.
+
+## Installation
+```bash
+$ pip install joulectl
+```
+
+## Using joulectl
+The tool provides a number of commands to 
+support the deployment and management of Joule use case configurations
+
+### Setup tool
+First create a configuration file
+```bash
+joulectl config create
+```
+
+Now update the Joule host which you would like to connect too.
+The default is ```localhost:9080```
+```bash
+joulectl config update --host 192.168.86.48:9080
+```
+
+You are now ready to deploy and manage joule remotely.
+
+## Commands
+List of available commands
+
+### deploy
+Deploy command for transports, streams and use cases.
+
+#### Subcommands
+- ```stream```     Deploy a stream
+- ```transport```  Deploy a transport
+- ```usecase```    Deploy a use case
+
+### list
+List deployed transports, streams and use cases.
+
+#### Subcommands
+- ```transports``` List transport by provided type
+- ```streams```   List registered streams
+- ```usecases```  List use cases
+
+### inspect
+Display deployed specification for transports, streams and use caase.
+
+#### Subcommands
+- ```stream```     Get a stream specification
+- ```transport```  Get a transport specification
+- ```usecase```    Get a use case specification
+
+### usecase
+Management command for use cases.
+
+#### Subcommands
+- ```pause```   Pause use case processing
+- ```resume```  Resume use case processing
+
+### undeploy
+Use case management command for transports, streams and use cases.
+
+#### Subcommands
+- ```stream```     Undeploy stream
+- ```transport```  Undeploy transport by provided type
+- ```usecase```    Undeploy use case
+
+### config
+Configure tool setting.
+
+#### Subcommands
+- ```create```  Create a new configuration file.
+- ```show```    Show configuration setting.
+- ```update```  Update configuration setting.
+
+## Resources
+- Discord Joule [server](https://discord.com/channels/1080521605786116196/1080521606247493724)
+- User and developer [documentation](https://docs.fractalworks.io/joule) 
+- Joule [website](https://getjoule.io) 
+
+## License
+Joule Tools are released under an MIT License.

joulectl-0.1.3/joulectl/commands/deploycmds.py

@@ -0,0 +1,72 @@
+import click
+from tabulate import tabulate
+from joulectl import joulecomms as jc
+
+def executeDeploy(url: str, filename: str, params: dict, host: str):
+    response = jc.postData(url=url,
+                           filename=filename,
+                           params=params,
+                           headers={"Content-Type": "application/json; charset=utf-8"},
+                           host=host)
+    if params["pod"]:
+        data = response.json()
+        table = []
+        for rsp in data["hostResponses"]:
+            cmd = rsp["command"]
+            msg = rsp["message"]
+            code = rsp["serviceCode"]
+        table.append([rsp["host"], cmd, code, msg])
+        click.echo(tabulate(table, headers=["Host","Command", "Response", "Message"]))
+    else:
+       click.echo(response.text)
+
+@click.command()
+@click.argument("filename", type=click.Path(exists=True))
+@click.option("--pod", help="Joule pod name", default="")
+@click.pass_context
+def transport(ctx: click.Context, filename: str, pod: str):
+    """Deploy transport to the Joule server.
+
+    FILENAME is the specification file to deploy
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/transports/register"
+    options = {'pod':pod}
+    executeDeploy(url=url,
+                filename=filename,
+                params=options,
+                host=joule_host)
+
+@click.command()
+@click.argument("filename",type=click.Path(exists=True))
+@click.option("--pod", help="Joule pod name", default="")
+@click.pass_context
+def stream(ctx: click.Context, filename: str, pod: str):
+    """Deploy a stream to the Joule server.
+
+    FILENAME is the specification file to deploy
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/stream/register"
+    options = {'pod':pod}
+    executeDeploy(url=url,
+                  filename=filename,
+                  params=options,
+                  host=joule_host)
+
+@click.command()
+@click.argument("filename", type=click.Path(exists=True))
+@click.option("--pod", help="Joule pod name", default="")
+@click.pass_context
+def usecase(ctx: click.Context, filename: str, pod: str):
+    """Deploy use case to the Joule server.
+
+    FILENAME is the specification file to deploy
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/usecase/deploy"
+    params = {'pod':pod}
+    executeDeploy(url=url,
+                  filename=filename,
+                  params=params,
+                  host=joule_host)

joulectl-0.1.3/joulectl/commands/inspectcmds.py

@@ -0,0 +1,70 @@
+import click
+import json
+import requests
+
+def executeDetail(url: str, params: dict, filename: str):
+    response = requests.get(url, params=params)
+    if response.status_code == 652:
+        click.echo("Resource not found")
+        return
+
+    if response.status_code == 200:
+        data = response.json()
+        with open(filename, 'w') as f:
+            json.dump(data,f, ensure_ascii=False)
+
+@click.command()
+@click.pass_context
+@click.argument("name")
+@click.argument("type")
+@click.option("--pod", help="Joule pod name", default="")
+@click.option("--filename", help="filename to use for returned specification", default="")
+def transport(ctx: click.Context, name: str, type: str, pod: str, filename: str):
+    """Return a transport specification as a file
+
+    NAME of the transport \n
+    TYPE must be one of: SOURCE or SINK
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/transports/detail"
+    params = {'type': type, 'name': name, 'pod': pod}
+    specfilename = name + ".json"
+    if filename:
+        specfilename = filename
+    executeDetail(url, params=params, filename=specfilename)
+
+@click.command()
+@click.pass_context
+@click.argument("name")
+@click.option("--pod", help="Joule pod name", default="")
+@click.option("--filename", help="filename to use for returned specification", default="")
+def stream(ctx: click.Context, name: str, pod: str, filename: str):
+    """Return a stream specification as a file
+
+    NAME of the stream
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/stream/detail"
+    params = {'name': name, 'pod': pod}
+    specfilename = name + ".json"
+    if filename:
+        specfilename = filename
+    executeDetail(url, params=params, filename=specfilename)
+
+@click.command()
+@click.pass_context
+@click.argument("name")
+@click.option("--pod", help="Joule pod name", default="")
+@click.option("--filename", help="filename to use for returned specification", default="")
+def usecase(ctx: click.Context, name: str,pod: str, filename: str):
+    """Return a use case specification as a file
+
+    NAME of the use case
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/usecase/detail"
+    params = {'name': name, 'pod':pod}
+    specfilename = name + ".json"
+    if filename:
+        specfilename = filename
+    executeDetail(url, params=params,filename=specfilename)

joulectl-0.1.3/joulectl/commands/listcmds.py

@@ -0,0 +1,134 @@
+import click
+import requests
+from tabulate import tabulate
+
+from joulectl import joulecomms as jc
+
+def displayTransportList(response: requests.Response):
+    table = []
+    if response.status_code != 204:
+        data = response.json()
+        for key in data.keys():
+            dd = data.get(key)
+            table.append([key, dd.get("x"), dd.get("y")])
+    click.echo(tabulate(table, headers=["Name", "Type","Description"]))
+
+@click.command()
+@click.pass_context
+def pods(ctx: click.Context):
+    """List running pods with the number of running joule processes"""
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/pods/list"
+    response = jc.callServer(method="GET",url=url, host=joule_host, headers={}, params={})
+    table = []
+    if response.status_code != 204:
+        data = response.json()
+        for element in data:
+            pod = element['name']
+            members = element['members']
+            table.append([pod,members])
+
+    click.echo(tabulate(table, headers=["Pod", "Members"]))
+
+@click.command()
+@click.argument("pod")
+@click.pass_context
+def members(ctx: click.Context, pod: str):
+    """List running members within a pod
+
+    POD name
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/pods/connected"
+    response = jc.callServer(method="GET",url=url, host=joule_host, headers={}, params={'pod':pod})
+    table = []
+    if response.status_code != 204:
+        data = response.json()
+        for host in data:
+            for process in data[host]:
+                created = data[host][process]["created"]
+                updated = data[host][process]["updated"]
+                status = data[host][process]["status"]
+                table.append([host,process,status, created, updated])
+
+    click.echo(tabulate(table, headers=["Host", "Process", "Status", "Created At", "Updated At"]))
+
+@click.command()
+@click.option("--pod", prompt=False)
+@click.option("--type", prompt=False)
+@click.pass_context
+def transports(ctx: click.Context, pod: str, type: str):
+    """List deployed transports
+
+    POD name \n
+    TYPE must be one of: SOURCE or SINK if provided, otherwise all transports are listed
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/transports/list"
+    if type == "SOURCE" or type == "SINK":
+        response = jc.callServer(method="GET",url=url, host=joule_host, headers={}, params={'type':type, 'pod':pod})
+        displayTransportList(response)
+    else:
+        response = jc.callServer(method="GET",url=url, host=joule_host, headers={}, params={})
+        table = []
+        if response.status_code != 204:
+            data = response.json()
+            for e in data:
+                pod = e["pod"]
+                name = e["name"]
+                transport = e["transport"]
+                type = e["type"]
+                created = e["created_at"]
+                table.append([pod,name,transport, type,created])
+            click.echo(tabulate(table, headers=["Pod", "Name", "Transport", "Type", "Created At"]))
+
+@click.command()
+@click.option("--pod", prompt=False)
+@click.pass_context
+def streams(ctx: click.Context, pod:str):
+    """List registered streams
+
+    POD name
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/stream/list"
+
+    response = jc.callServer(method="GET", url=url, host=joule_host, headers={}, params={'pod':pod})
+    table = []
+    if response.status_code != 204:
+        data = response.json()
+        for e in data:
+            pod = e["pod"]
+            name = e["name"]
+            metrics_enabled = e["metrics_enabled"]
+            telemetry_enabled = e["telemetry_enabled"]
+            valid_from = e["valid_from"]
+            valid_to = e["valid_to"]
+            created = e["created_at"]
+            table.append([pod,name,metrics_enabled,telemetry_enabled, valid_from,valid_to,created])
+        click.echo(tabulate(table, headers=["Pod", "Name", "Metrics Enabled","Telemetry Enabled","Valid From", "Valid To", "Created At"]))
+
+@click.command()
+@click.pass_context
+def usecases(ctx: click.Context):
+    """List all deployed use cases
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/usecase/list"
+    response = jc.callServer(method="GET", url=url, host=joule_host, headers={}, params={})
+    data = response.json()
+    click.echo(data)
+    table = []
+    for element in data:
+        pod = element['pod']
+        name = element['name']
+        stream = element['stream']
+        sources = element['sources']
+        sinks = element['sinks']
+        refData = element['ref_data']
+        validFrom = element['valid_from']
+        validTo = element['valid_to']
+        createdAt = element['created_at']
+        table.append([pod,name,stream, sources, sinks, refData, validFrom, validTo, createdAt])
+    click.echo(tabulate(table, headers=["Pod","Name","Stream","Sources","Sinks","Reference Data", "Valid From", "Valid To","Created At"]))
+

joulectl-0.1.3/joulectl/commands/ucmgmtcmds.py

@@ -0,0 +1,47 @@
+import click
+import requests
+from tabulate import tabulate
+
+def displayResponse(name: str,response: requests.Response):
+    table = []
+    if response.status_code != 204:
+        data = response.json()
+        cmd = data["command"]
+        code = data["aggregatedServiceCode"]
+        table.append([name,cmd,code])
+        click.echo(tabulate(table, headers=["Name", "Command","Response"]))
+    else:
+        click.echo("Unknown use case - {}".format(name))
+
+@click.command()
+@click.pass_context
+@click.argument("name")
+@click.option("--pod", help="Joule pod name", default="")
+def resume(ctx: click.Context, name: str, pod: str):
+    """Resume use case processing
+
+    NAME is the use case
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/usecase/resume"
+    params={"name": name, "pod": pod}
+    response = requests.request(method="PUT", url=url, params=params)
+    if response.status_code != 204:
+        displayResponse(name,response)
+
+
+@click.command()
+@click.argument("name")
+@click.pass_context
+@click.option("--pod", help="Joule pod name", default="")
+def pause(ctx: click.Context, name: str, pod: str):
+    """Pause use case processing
+
+    NAME is the use case
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/usecase/pause"
+    params={"name": name, "pod": pod}
+    response = requests.request(method="PUT", url=url, params=params)
+    if response.status_code != 204:
+        displayResponse(name,response)

joulectl-0.1.3/joulectl/commands/undeploycmds.py

@@ -0,0 +1,74 @@
+import click
+import requests
+from tabulate import tabulate
+from joulectl import joulecomms as jc
+
+def displayResponse(pod: str, response: requests.Response):
+    if pod:
+        data = response.json()
+        table = []
+        for rsp in data["hostResponses"]:
+            cmd = rsp["command"]
+            msg = rsp["message"]
+            code = rsp["serviceCode"]
+        table.append([rsp["host"], cmd, code, msg])
+        click.echo(tabulate(table,headers=["Host","Command", "Response", "Message"]))
+    else:
+        click.echo(response.text)
+
+@click.command()
+@click.option("--pod", help="Joule pod name", default="")
+@click.argument("name")
+@click.argument("type")
+@click.pass_context
+def transport(ctx: click.Context, pod: str, name: str, type: str):
+    """Undeploy transport
+
+    NAME of the transport \n
+    TYPE must be one of: SOURCE or SINK
+    """
+    if type == "SOURCE" or type == "SINK":
+        joule_host = ctx.obj["joule_host"]
+
+        url = f"http://{joule_host}/joule/management/transports/unregister"
+        params = {'name': name, 'type': type, 'pod': pod}
+        response = jc.callServer(method="DELETE", url=url, host=joule_host, headers={},params=params)
+        if response.status_code == 200:
+            displayResponse(pod, response)
+        else:
+            click.echo(response.text)
+    else:
+        click.echo("Unknown transport type: {}".format(type))
+
+@click.command()
+@click.option("--pod", help="Joule pod name", default="")
+@click.argument("name")
+@click.pass_context
+def stream(ctx: click.Context, name: str, pod: str):
+    """Undeploy stream
+
+    NAME of stream
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/stream/unregister"
+    params = {'name': name, 'pod': pod}
+    response = jc.callServer(method="DELETE", url=url, host=joule_host, headers={},params=params)
+    if response.status_code == 200:
+        displayResponse(pod, response)
+    else:
+        click.echo(response.text)
+
+@click.command()
+@click.option("--pod", help="Joule pod name", default="")
+@click.argument("name")
+@click.pass_context
+def usecase(ctx: click.Context, name: str, pod: str):
+    """Undeploy use case
+
+    NAME of use case
+    """
+    joule_host = ctx.obj["joule_host"]
+    url = f"http://{joule_host}/joule/management/usecase/undeploy"
+    params = {'name': name, 'pod': pod}
+    response = jc.callServer(method="DELETE", url=url, host=joule_host, headers={},params=params)
+    displayResponse(pod, response)

joulectl-0.1.3/joulectl/config/config.py

@@ -0,0 +1,19 @@
+import json
+from pathlib import Path
+from typing import Any
+
+CONFIG_DIR = Path.home() / ".config" / "joule"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+DEFAULT_JOULE_HOST = "127.0.0.1:9080"
+
+def load_config(config_path: Path = CONFIG_FILE):
+    if not config_path.exists():
+        return {"joule_dir": str(CONFIG_DIR)}
+    with open(config_path, "r") as file:
+        return json.load(file)
+
+def save_config(config: dict[str, Any]):
+    if not CONFIG_DIR.exists():
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_FILE, "w") as file:
+        json.dump(config, file, indent=4)

joulectl-0.1.3/joulectl/config/file.py

@@ -0,0 +1,57 @@
+import os
+
+from config import load_config
+
+
+def create_files(pattern: str, start: int = 0, end: int = 10) -> list[str]:
+    config = load_config()
+    joule_dir = config.get("joule_dir")
+
+    if joule_dir is None:
+        raise ValueError("Joule directory not configured.")
+
+    base_name, extension = pattern.split("*")
+    extension = extension.lstrip(".")
+
+    files: list[str] = []
+    for i in range(start, end + 1):
+        file_name = f"{base_name}{i}.{extension}"
+
+        if exists(file_name):
+            continue
+
+        with open(os.path.join(joule_dir, file_name), "w") as file:
+            file.write(f"This is the content of {file_name}\n")
+        files.append(file_name)
+
+    return files
+
+
+def load(path: str):
+    config = load_config()
+    joule_dir = config.get("joule_dir")
+
+    if joule_dir is None:
+        raise ValueError("Joule directory not configured.")
+
+    with open(os.path.join(joule_dir, path), "r") as file:
+        return file.read()
+
+
+def save(path: str, content: str):
+    config = load_config()
+    joule_dir = config.get("joule_dir")
+
+    if joule_dir is None:
+        raise ValueError("Joule directory not configured.")
+    with open(os.path.join(joule_dir, path), "w+") as file:
+        file.write(content)
+
+
+def exists(path: str):
+    config = load_config()
+    joule_dir = config.get("joule_dir")
+
+    if joule_dir is None:
+        raise ValueError("Joule directory not configured.")
+    return os.path.isfile(os.path.join(joule_dir, path))

joulectl-0.1.3/joulectl/joule.py

@@ -0,0 +1,108 @@
+import click
+from tabulate import tabulate
+
+from joulectl.commands import listcmds, deploycmds, inspectcmds, undeploycmds, ucmgmtcmds
+from joulectl.config.config import CONFIG_FILE, DEFAULT_JOULE_HOST, load_config, save_config
+
+@click.group()
+@click.version_option()
+@click.pass_context
+def cli(ctx: click.Context):
+    """Joule deployment and management tool \n
+    joulctl version 0.1.3
+    """
+    tc = load_config()
+
+    # Initialise ctx with empty dict
+    ctx.ensure_object(dict)
+    ctx.obj["joule_host"] = tc.get("joule_host", DEFAULT_JOULE_HOST)
+    ctx.obj["config"] = tc
+
+@cli.group()
+def ls():
+    """List deployed transports, streams and use cases."""
+    pass
+
+@cli.group()
+def deploy():
+    """Deploy command for transports, streams and use cases."""
+    pass
+
+@cli.group()
+def undeploy():
+    """Undeploy command for transports, streams and use cases."""
+    pass
+
+@cli.group()
+def process():
+    """Management command for use cases"""
+    pass
+
+@cli.group()
+def inspect():
+    """Get deployed specifications for transports, streams and use cases."""
+    pass
+
+@cli.group()
+def config():
+    """Configure joulectl setting."""
+    pass
+
+@config.command()
+def create():
+    """Create a new configuration file."""
+    nc = load_config()
+    save_config(nc)
+    click.echo("Configuration created.")
+
+@config.command()
+def show():
+    """Show configuration setting"""
+    if not CONFIG_FILE.exists():
+        click.echo("No configuration found.")
+        return
+    displyConfiguration()
+
+@config.command()
+@click.argument("host")
+def update(host: str):
+    """Update configuration setting for joule host.
+
+    HOST address and port send commands too e.g., 192.168.1.10:60110
+    """
+    cg = load_config()
+    if host:
+        cg['joule_host'] = host
+        save_config(cg)
+        click.echo(f"Joule host set to {host}")
+
+def displyConfiguration():
+    dc = load_config()
+    table = []
+    for key, value in dc.items():
+        table.append([key, value])
+
+    click.echo(tabulate(table, headers=["Key", "Configuration"]))
+
+
+## Command setting
+ls.add_command(listcmds.transports)
+ls.add_command(listcmds.streams)
+ls.add_command(listcmds.usecases)
+ls.add_command(listcmds.pods)
+ls.add_command(listcmds.members)
+
+deploy.add_command(deploycmds.transport)
+deploy.add_command(deploycmds.stream)
+deploy.add_command(deploycmds.usecase)
+
+process.add_command(ucmgmtcmds.pause)
+process.add_command(ucmgmtcmds.resume)
+
+undeploy.add_command(undeploycmds.transport)
+undeploy.add_command(undeploycmds.stream)
+undeploy.add_command(undeploycmds.usecase)
+
+inspect.add_command(inspectcmds.transport)
+inspect.add_command(inspectcmds.stream)
+inspect.add_command(inspectcmds.usecase)

joulectl-0.1.3/joulectl/joulecomms.py

@@ -0,0 +1,21 @@
+import requests
+import json
+
+def callServer(method: str, url: str, host: str, headers: dict, params: dict):
+    try:
+        response = requests.request(method=method, url=url, headers=headers, params=params)
+    except requests.ConnectionError as e:
+        print("Error connecting to Joule server: {}".format(host))
+        exit(1)
+    return response
+
+
+def postData(url: str, filename: str, params: dict, host: str, headers: dict):
+    with open(filename) as json_data:
+        data = json.load(json_data)
+        try:
+            response = requests.post(url, headers=headers, json=data, params=params)
+        except requests.ConnectionError as e:
+            print("Error connecting to Joule server: {}".format(host))
+            exit(1)
+    return response

joulectl-0.1.3/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "joulectl"
+version = "0.1.3"
+description = "Joule CLI tool to manage Joule transports, streams and use cases"
+authors = [
+    {name = "Lyndon Adams",email = "lyndon.adams@fractalworks.io"}
+]
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "click (>=8.1.8,<9.0.0)",
+    "requests (>=2.32.3,<3.0.0)",
+    "tabulate (>=0.9.0,<1.0.0)"
+]
+packages = [
+    { include = "app" },
+]
+
+license = { text = "MIT" }
+keywords = [ "joule", "streaming" ]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+homepage = "https://https://getjoule.io/"
+documentation = "https://docs.fractalworks.io/joule"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.group.dev.dependencies]
+twine = "^6.1.0"
+
+[tool.poetry]
+package-mode = true
+
+[tool.poetry.scripts]
+joulectl = "joulectl.joule:cli" # entrypoint to the CLI