neuronum 1.5.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

cli/main.py

@@ -0,0 +1,589 @@
+import click
+import questionary
+from pathlib import Path
+import requests
+import subprocess
+import os
+import neuronum
+import json
+
+@click.group()
+def cli():
+    """Neuronum CLI Tool"""
+
+
+@click.command()
+def create_cell():
+    cell_type = questionary.select(
+        "Choose Cell type:",
+        choices=["business", "community"]
+    ).ask()
+
+    network = questionary.select(
+        "Choose Network:",
+        choices=["neuronum.net"]
+    ).ask()
+
+    if cell_type == "business":
+        click.echo("Visit https://neuronum.net/createcell to create your Neuronum Business Cell")
+
+    if cell_type == "community":
+
+        email = click.prompt("Enter email")
+        password = click.prompt("Enter password", hide_input=True)
+        repeat_password = click.prompt("Repeat password", hide_input=True)
+
+        if password != repeat_password:
+            click.echo("Passwords do not match!")
+            return
+
+        url = f"https://{network}/api/create_cell/{cell_type}"
+
+        create_cell = {"email": email, "password": password}
+
+        try:
+            response = requests.post(url, json=create_cell)
+            response.raise_for_status()
+            status = response.json()["status"]
+
+        except requests.exceptions.RequestException as e:
+            click.echo(f"Error sending request: {e}")
+            return
+        
+        if status == True:
+            host = response.json()["host"]
+            cellkey = click.prompt(f"Please verify your email address with the Cell Key send to {email}")
+
+            url = f"https://{network}/api/verify_email"
+
+            verify_email = {"host": host, "email": email, "cellkey": cellkey}
+
+            try:
+                response = requests.post(url, json=verify_email)
+                response.raise_for_status()
+                status = response.json()["status"]
+
+            except requests.exceptions.RequestException as e:
+                click.echo(f"Error sending request: {e}")
+                return
+        
+            if status == True:
+                synapse = response.json()["synapse"]
+                credentials_folder_path = Path.home() / ".neuronum"
+                credentials_folder_path.mkdir(parents=True, exist_ok=True)
+
+                env_path = credentials_folder_path / ".env"
+                env_path.write_text(f"HOST={host}\nPASSWORD={password}\nNETWORK={network}\nSYNAPSE={synapse}\n")
+
+                click.echo(f"Welcome to Neuronum! Community Cell '{host}' created and connected!")
+
+        if status == False:
+            click.echo(f"Error:'{email}' already assigned!")
+
+
+
+@click.command()
+def connect_cell():
+    email = click.prompt("Enter your Email")
+    password = click.prompt("Enter password", hide_input=True)
+
+    network = questionary.select(
+        "Choose Network:",
+        choices=["neuronum.net"]
+    ).ask()
+
+    url = f"https://{network}/api/connect_cell"
+    payload = {"email": email, "password": password}
+
+    try:
+        response = requests.post(url, json=payload)
+        response.raise_for_status()
+        status = response.json()["status"]
+        host = response.json()["host"]
+    except requests.exceptions.RequestException as e:
+        click.echo(f"Error connecting: {e}")
+        return
+    
+    if status == True:
+        cellkey = click.prompt(f"Please verify your email address with the Cell Key send to {email}")
+        url = f"https://{network}/api/verify_email"
+        verify_email = {"host": host, "email": email, "cellkey": cellkey}
+
+        try:
+            response = requests.post(url, json=verify_email)
+            response.raise_for_status()
+            status = response.json()["status"]
+            synapse = response.json()["synapse"]
+
+        except requests.exceptions.RequestException as e:
+            click.echo(f"Error sending request: {e}")
+            return
+
+        if status == True:
+            credentials_folder_path = Path.home() / ".neuronum"
+            credentials_folder_path.mkdir(parents=True, exist_ok=True)
+
+            env_path = credentials_folder_path / f".env"
+            env_path.write_text(f"HOST={host}\nPASSWORD={password}\nNETWORK={network}\nSYNAPSE={synapse}\n")
+
+            click.echo(f"Cell '{host}' connected!")
+    else:
+        click.echo(f"Connection failed!")
+
+
+@click.command()
+def view_cell():
+    credentials_folder_path = Path.home() / ".neuronum"
+    env_path = credentials_folder_path / ".env"
+
+    env_data = {}
+
+    try:
+        with open(env_path, "r") as f:
+            for line in f:
+                key, value = line.strip().split("=")
+                env_data[key] = value
+
+        host = env_data.get("HOST", "")
+
+    except FileNotFoundError:
+        click.echo("Error: No credentials found. Please connect to a cell first.")
+        return
+    except Exception as e:
+        click.echo(f"Error reading .env file: {e}")
+        return
+
+    if host:
+        click.echo(f"Connected Cell: '{host}'")
+    else:
+        click.echo("No active cell connection found.")
+
+
+@click.command()
+def disconnect_cell():
+    credentials_folder_path = Path.home() / ".neuronum"
+    env_path = credentials_folder_path / ".env"
+
+    env_data = {}
+
+    try:
+        with open(env_path, "r") as f:
+            for line in f:
+                key, value = line.strip().split("=")
+                env_data[key] = value
+
+        host = env_data.get("HOST", "")
+
+    except FileNotFoundError:
+        click.echo("Error: .env with credentials not found")
+        return
+    except Exception as e:
+        click.echo(f"Error reading .env file: {e}")
+        return
+
+    if env_path.exists():
+        if click.confirm(f"Are you sure you want to disconnect Cell '{host}'?", default=True):
+            os.remove(env_path)
+            click.echo(f"'{host}' disconnected!")
+        else:
+            click.echo("Disconnect canceled.")
+    else:
+        click.echo(f"No Neuronum Cell connected!")
+
+
+@click.command()
+def delete_cell():
+    credentials_folder_path = Path.home() / ".neuronum"
+    env_path = credentials_folder_path / ".env"
+
+    env_data = {}
+
+    try:
+        with open(env_path, "r") as f:
+            for line in f:
+                key, value = line.strip().split("=")
+                env_data[key] = value
+
+        host = env_data.get("HOST", "")
+        password = env_data.get("PASSWORD", "")
+        network = env_data.get("NETWORK", "")
+        synapse = env_data.get("SYNAPSE", "")
+
+    except FileNotFoundError:
+        click.echo("Error: No cell connected. Connect Cell first to delete")
+        return
+    except Exception as e:
+        click.echo(f"Error reading .env file: {e}")
+        return
+
+    confirm = click.confirm(f" Are you sure you want to delete '{host}'?", default=True)
+    if not confirm:
+        click.echo("Deletion canceled.")
+        return
+
+    url = f"https://{network}/api/delete_cell"
+    payload = {"host": host, "password": password, "synapse": synapse}
+
+    try:
+        response = requests.delete(url, json=payload)
+        response.raise_for_status()
+        status = response.json()["status"]
+    except requests.exceptions.RequestException as e:
+        click.echo(f"Error deleting cell: {e}")
+        return
+    
+    if status == True:
+        env_path = credentials_folder_path / f"{host}.env"
+        if env_path.exists():
+            os.remove(env_path)
+            click.echo("Credentials deleted successfully!")
+        click.echo(f"Neuronum Cell '{host}' has been deleted!")
+    else: 
+        click.echo(f"Neuronum Cell '{host}' deletion failed!")
+ 
+
+@click.command()
+@click.option('--sync', default=None, help="Optional stream ID to generate the sync template.")
+def init_node(sync):
+
+    node_type = questionary.select(
+        "Choose Node type:",
+        choices=["public", "private"]
+    ).ask()
+
+    descr = click.prompt("Node description (max. 25 characters)")
+
+    stream = sync if sync else "n9gW3LxQcecI::stx"
+
+    credentials_folder_path = Path.home() / ".neuronum"
+    env_path = credentials_folder_path / ".env"
+
+    env_data = {}
+
+    try:
+        with open(env_path, "r") as f:
+            for line in f:
+                key, value = line.strip().split("=")
+                env_data[key] = value
+
+        host = env_data.get("HOST", "")
+        password = env_data.get("PASSWORD", "")
+        network = env_data.get("NETWORK", "")
+        synapse = env_data.get("SYNAPSE", "")
+
+    except FileNotFoundError:
+        click.echo("No cell connected. Connect your cell with command neuronum connect-cell")
+        return
+    except Exception as e:
+        click.echo(f"Error reading .env file: {e}")
+        return
+
+    cell = neuronum.Cell(
+    host=host,         
+    password=password,                         
+    network=network,                        
+    synapse=synapse
+    )
+
+    tx = cell.list_tx()
+    ctx = cell.list_ctx()
+    stx = cell.list_stx()
+    contracts = cell.list_contracts()
+
+    url = f"https://{network}/api/init_node/{node_type}"
+
+    node = {"descr": descr, "host": host, "password": password, "synapse": synapse}
+
+    try:
+        response = requests.post(url, json=node)
+        response.raise_for_status()
+        nodeID = response.json()["nodeID"]
+    except requests.exceptions.RequestException as e:
+        click.echo(f"Error sending request: {e}")
+        return
+
+    node_filename = "node_" + nodeID.replace("::node", "")
+    project_path = Path(node_filename)
+    project_path.mkdir(exist_ok=True)
+
+    env_path = project_path / ".env"
+    env_path.write_text(f"NODE={nodeID}\nHOST={host}\nPASSWORD={password}\nNETWORK={network}\nSYNAPSE={synapse}\n")
+
+    gitignore_path = project_path / ".gitignore"
+    gitignore_path.write_text(f".env\n")
+
+    tx_path = project_path / "transmitters.json"
+    tx_path.write_text(json.dumps(tx, indent=4))
+
+    ctx_path = project_path / "circuits.json"
+    ctx_path.write_text(json.dumps(ctx, indent=4))
+
+    stx_path = project_path / "streams.json"
+    stx_path.write_text(json.dumps(stx, indent=4))
+
+    contracts_path = project_path / "contracts.json"
+    contracts_path.write_text(json.dumps(contracts, indent=4))
+
+    nodemd_path = project_path / "NODE.md"
+    nodemd_path.write_text("""\
+## Use this NODE.md file to add instructions on how to interact with your node                        
+""")
+        
+    main_path = project_path / "main.py"
+    main_path.write_text(f"""\
+import neuronum
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+host = os.getenv("HOST")
+password = os.getenv("PASSWORD")
+network = os.getenv("NETWORK")
+synapse = os.getenv("SYNAPSE")
+
+cell = neuronum.Cell(
+    host=host,
+    password=password,
+    network=network,
+    synapse=synapse
+)
+
+STX = "{stream}"
+stream = cell.sync(STX)
+for operation in stream:
+    label = operation.get("label")
+    value = operation.get("data").get("message")
+    ts = operation.get("time")
+    stxID = operation.get("stxID")
+    operator = operation.get("operator")
+    print(label, value, ts, stxID, operator)                              
+""")
+
+    click.echo(f"Neuronum Node '{nodeID}' initialized!")
+
+
+@click.command()
+def start_node():
+    click.echo("Starting Node...")
+
+    project_path = Path.cwd()
+    main_file = project_path / "main.py"
+
+    if not main_file.exists():
+        click.echo("Error: main.py not found. Make sure the node is set up.")
+        return
+
+    process = subprocess.Popen(["python", str(main_file)], start_new_session=True)
+
+    with open("node_pid.txt", "w") as f:
+        f.write(str(process.pid))
+
+    click.echo("Node started successfully!")
+
+
+@click.command()
+def stop_node():
+    click.echo("Stopping Node...")
+
+    try:
+        with open("node_pid.txt", "r") as f:
+            pid = int(f.read().strip())
+        os.kill(pid, 9) 
+        os.remove("node_pid.txt")
+        click.echo("Node stopped successfully!")
+    except FileNotFoundError:
+        click.echo("Error: No active node process found.")
+    except Exception as e:
+        click.echo(f"Error stopping node: {e}")
+
+
+@click.command()
+def register_node():
+    env_data = {}
+    try:
+        with open(".env", "r") as f:
+            for line in f:
+                key, value = line.strip().split("=")
+                env_data[key] = value
+
+        nodeID = env_data.get("NODE", "")
+        host = env_data.get("HOST", "")
+        password = env_data.get("PASSWORD", "")
+        network = env_data.get("NETWORK", "")
+        synapse = env_data.get("SYNAPSE", "")
+
+    except FileNotFoundError:
+        print("Error: .env with credentials not found")
+        return
+    except Exception as e:
+        print(f"Error reading .env file: {e}")
+        return
+
+    try:
+        with open("NODE.md", "r") as f: 
+            nodemd_file = f.read() 
+
+    except FileNotFoundError:
+        print("Error: NODE.md file not found")
+        return
+    except Exception as e:
+        print(f"Error reading NODE.md file: {e}")
+        return
+
+    url = f"https://{network}/api/register_node"
+
+    node = {
+        "nodeID": nodeID,
+        "host": host,
+        "password": password,
+        "synapse": synapse,
+        "nodemd_file": nodemd_file
+    }
+
+    try:
+        response = requests.post(url, json=node)
+        response.raise_for_status()
+        nodeID = response.json()["nodeID"]
+        node_url = response.json()["node_url"]
+    except requests.exceptions.RequestException as e:
+        click.echo(f"Error sending request: {e}")
+        return
+
+    click.echo(f"Neuronum Node '{nodeID}' registered! Visit: {node_url}")
+
+
+@click.command()
+def update_node():
+    env_data = {}
+    try:
+        with open(".env", "r") as f:
+            for line in f:
+                key, value = line.strip().split("=")
+                env_data[key] = value
+
+        nodeID = env_data.get("NODE", "")
+        host = env_data.get("HOST", "")
+        password = env_data.get("PASSWORD", "")
+        network = env_data.get("NETWORK", "")
+        synapse = env_data.get("SYNAPSE", "")
+
+    except FileNotFoundError:
+        print("Error: .env with credentials not found")
+        return
+    except Exception as e:
+        print(f"Error reading .env file: {e}")
+        return
+
+    try:
+        with open("NODE.md", "r") as f: 
+            nodemd_file = f.read() 
+
+    except FileNotFoundError:
+        print("Error: NODE.md file not found")
+        return
+    except Exception as e:
+        print(f"Error reading NODE.md file: {e}")
+        return
+
+    url = f"https://{network}/api/update_node"
+
+    node = {
+        "nodeID": nodeID,
+        "host": host,
+        "password": password,
+        "synapse": synapse,
+        "nodemd_file": nodemd_file
+    }
+
+    try:
+        response = requests.post(url, json=node)
+        response.raise_for_status()
+        nodeID = response.json()["nodeID"]
+        node_url = response.json()["node_url"]
+    except requests.exceptions.RequestException as e:
+        click.echo(f"Error sending request: {e}")
+        return
+    
+
+    cell = neuronum.Cell(
+    host=host,         
+    password=password,                         
+    network=network,                        
+    synapse=synapse
+    )
+
+    tx = cell.list_tx()
+    ctx = cell.list_ctx()
+    stx = cell.list_stx()
+    contracts = cell.list_contracts()
+
+    tx_path = Path("transmitters.json")
+    ctx_path = Path("circuits.json")
+    stx_path = Path("streams.json")
+    contracts_path = Path("contracts.json")
+
+    tx_path.write_text(json.dumps(tx, indent=4))
+    ctx_path.write_text(json.dumps(ctx, indent=4))
+    stx_path.write_text(json.dumps(stx, indent=4))
+    contracts_path.write_text(json.dumps(contracts, indent=4))
+
+    click.echo(f"Neuronum Node '{nodeID}' updated! Visit: {node_url}")
+
+
+@click.command()
+def delete_node():
+    env_data = {}
+    try:
+        with open(".env", "r") as f:
+            for line in f:
+                key, value = line.strip().split("=")
+                env_data[key] = value
+
+        nodeID = env_data.get("NODE", "")
+        host = env_data.get("HOST", "")
+        password = env_data.get("PASSWORD", "")
+        network = env_data.get("NETWORK", "")
+        synapse = env_data.get("SYNAPSE", "")
+
+    except FileNotFoundError:
+        print("Error: .env with credentials not found")
+        return
+    except Exception as e:
+        print(f"Error reading .env file: {e}")
+        return
+
+    url = f"https://{network}/api/delete_node"
+
+    node = {
+        "nodeID": nodeID,
+        "host": host,
+        "password": password,
+        "synapse": synapse
+    }
+
+    try:
+        response = requests.post(url, json=node)
+        response.raise_for_status()
+        nodeID = response.json()["nodeID"]
+    except requests.exceptions.RequestException as e:
+        click.echo(f"Error sending request: {e}")
+        return
+
+    click.echo(f"Neuronum Node '{nodeID}' deleted!")
+
+
+cli.add_command(create_cell)
+cli.add_command(connect_cell)
+cli.add_command(view_cell)
+cli.add_command(disconnect_cell)
+cli.add_command(delete_cell)
+cli.add_command(init_node)
+cli.add_command(start_node)
+cli.add_command(stop_node)
+cli.add_command(register_node)
+cli.add_command(update_node)
+cli.add_command(delete_node)
+
+
+if __name__ == "__main__":
+    cli()

neuronum/neuronum.py

@@ -206,130 +206,56 @@ class Cell:
             print(f"Unexpected error: {e}")
 
 
-    def register_node(self, descr: str, mode: str, stx: str):
-        if mode == "public":
-            url = f"https://{self.network}/api/register_node/public"
-        elif mode == "private":
-            url = f"https://{self.network}/api/register_node/private"
-        else:
-            return {"error": "Invalid mode", "message": "Mode has to be 'public' or 'private'"}
-
-        node_data = {
-            "descr": descr,
-            "mode": mode,
-            "stream": stx,
-            "cell": self.to_dict()
-        }
-
-        try:
-            response = requests.post(
-                url,
-                json=node_data,
-            )
-
-            response.raise_for_status()
-
-            return response.json()["nodeID"]
-
-        except requests.exceptions.RequestException as e:
-            print(f"Error sending request: {e}")
-        except Exception as e:
-            print(f"Unexpected error: {e}")
-
-
-    def delete_node(self, nodeID: str):
-        url = f"https://{self.network}/api/delete_node"
-
-        delete_node = {
-            "nodeID": nodeID,
-            "cell": self.to_dict()
-        }
-
-        try:
-            response = requests.post(
-                url,
-                json=delete_node,
-            )
-
-            response.raise_for_status()
-            print(response.json())
-
-        except requests.exceptions.RequestException as e:
-            print(f"Error sending request: {e}")
-        except Exception as e:
-            print(f"Unexpected error: {e}")
-
-
-    def list_tx(self, cellID: str):
+    def list_tx(self):
         full_url = f"https://{self.network}/api/list_tx"
         
         list_tx = {
-            "cell": self.to_dict(),  
-            "cellID": cellID
+            "cell": self.to_dict()
         }
 
         try:
             response = requests.post(full_url, json=list_tx)
             response.raise_for_status()
-            return response.json()
+            return response.json()["Transmitters"]
         except requests.exceptions.RequestException as e:
             print(f"Error sending request: {e}")
         except Exception as e:
             print(f"Unexpected error: {e}")
 
 
-    def list_ctx(self, cellID: str):
+    def list_ctx(self):
         full_url = f"https://{self.network}/api/list_ctx"
         
         list_ctx = {
-            "cell": self.to_dict(),  
-            "cellID": cellID
+            "cell": self.to_dict()
         }
 
         try:
             response = requests.post(full_url, json=list_ctx)
             response.raise_for_status()
-            return response.json()
+            return response.json()["Circuits"]
         except requests.exceptions.RequestException as e:
             print(f"Error sending request: {e}")
         except Exception as e:
             print(f"Unexpected error: {e}")
 
 
-    def list_stx(self, cellID: str):
+    def list_stx(self):
         full_url = f"https://{self.network}/api/list_stx"
         
         list_stx = {
-            "cell": self.to_dict(),  
-            "cellID": cellID
+            "cell": self.to_dict()
         }
 
         try:
             response = requests.post(full_url, json=list_stx)
             response.raise_for_status()
-            return response.json()
+            return response.json()["Streams"]
         except requests.exceptions.RequestException as e:
             print(f"Error sending request: {e}")
         except Exception as e:
             print(f"Unexpected error: {e}")
 
-
-    def connect(self):
-            url = f"https://{self.network}/api/connect"
-
-            test = {
-                "cell": self.to_dict() 
-            }
-
-            try:
-                response = requests.post(url, json=test)
-                response.raise_for_status()
-                print(response.json()["connection"]) 
-            except requests.exceptions.RequestException as e:
-                print(f"Error sending request: {e}")
-            except Exception as e:
-                print(f"Unexpected error: {e}")
-
         
     def store(self, label: str, data: dict, ctx: Optional[str] = None):
         if ctx:
@@ -459,14 +385,13 @@ class Cell:
         try:
             ws = create_connection(f"wss://{self.network}/sync/{stx}")
             ws.send(json.dumps(auth))
-            print("Stream connection set...")
+            print("Listening to Stream...")
 
             try:
                 while True:
                     try:
                         raw_operation = ws.recv()
                         operation = json.loads(raw_operation)
-                        print("Listening to Stream...")
                         yield operation
 
                     except socket.timeout:
@@ -474,17 +399,147 @@ class Cell:
                         continue 
 
             except KeyboardInterrupt:
-                print("Stream-Synchronization ended!")
-            except Exception as e:
-                print(f"Error: {e}")
-            finally:
                 ws.close()
                 print("Connection closed.")
-
+            except Exception as e:
+                print(f"Error: {e}")
+ 
+                
         except KeyboardInterrupt:
             print("Stream-Synchronization ended!")
             ws.close()
             print("Connection closed. Goodbye!")
 
 
+    def sign_contract(self, contractID: str):
+            full_url = f"https://{self.network}/api/sign_contract"
+            
+            sign_contract = {
+                "contractID": contractID,
+                "cell": self.to_dict() 
+            }
+
+            try:
+                response = requests.post(full_url, json=sign_contract)
+                response.raise_for_status()
+                return response.json()["token"]
+            except requests.exceptions.RequestException as e:
+                print(f"Error sending request: {e}")
+            except Exception as e:
+                print(f"Unexpected error: {e}")
+
+
+    def validate_token(self, token: str, cp: str, contractID: str):
+        full_url = f"https://{self.network}/api/validate_token"
+        
+        validate = {
+            "token": token,
+            "cp": cp,
+            "contractID": contractID,
+            "cell": self.to_dict() 
+        }
+
+        try:
+            response = requests.post(full_url, json=validate)
+            response.raise_for_status()
+            return response.json()["validity"]
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def request_token(self, cp: str, contractID: str):
+        full_url = f"https://{self.network}/api/request_token"
+        
+        request_token = {
+            "cp": cp,
+            "contractID": contractID,
+            "cell": self.to_dict() 
+        }
+
+        try:
+            response = requests.post(full_url, json=request_token)
+            response.raise_for_status()
+            print(response.json())
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+    
+    def present_token(self, token: str, cp: str, contractID: str):
+        full_url = f"https://{self.network}/api/present_token"
+        
+        present_token = {
+            "token": token,
+            "cp": cp,
+            "contractID": contractID,
+            "cell": self.to_dict() 
+        }
+
+        try:
+            response = requests.post(full_url, json=present_token)
+            response.raise_for_status()
+            print(response.json()) 
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def create_contract(self, descr: str, details: dict, partners: list):
+        full_url = f"https://{self.network}/api/create_contract"
+        
+        create_contract = {
+            "cell": self.to_dict(),  
+            "descr": descr,
+            "details": details,
+            "partners": partners
+        }
+        try:
+            response = requests.post(full_url, json=create_contract)
+            response.raise_for_status()
+            return response.json()["contractID"]
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def delete_contract(self, contractID: str):
+        full_url = f"https://{self.network}/api/delete_contract"
+        
+        request = {
+            "cell": self.to_dict(),  
+            "contractID": contractID
+        }
+
+        try:
+            response = requests.post(full_url, json=request)
+            response.raise_for_status()
+            print(f"Response from Neuronum: {response.json()}")
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def list_contracts(self):
+        full_url = f"https://{self.network}/api/list_contracts"
+        
+        list_contracts = {
+            "cell": self.to_dict()
+        }
+
+        try:
+            response = requests.post(full_url, json=list_contracts)
+            response.raise_for_status()
+            return response.json()["Contracts"]
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
 __all__ = ['Cell']

{neuronum-1.5.1.dist-info → neuronum-1.7.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: neuronum
-Version: 1.5.1
-Summary: Interact with the Neuronum Network to build & automate interconnected networks of soft- and hardware components
+Version: 1.7.0
+Summary: Official client library to interact with the Neuronum Network
 Home-page: https://neuronum.net
 Author: Neuronum Cybernetics
 Author-email: welcome@neuronum.net
@@ -9,52 +9,98 @@ Project-URL: GitHub, https://github.com/neuronumcybernetics/neuronum
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests
 Requires-Dist: websocket-client
+Requires-Dist: click
+Requires-Dist: questionary
+Requires-Dist: python-dotenv
 
 ![Neuronum Logo](https://neuronum.net/static/logo_pip.png "Neuronum")
 
-[![Website](https://img.shields.io/badge/Website-Neuronum-blue)](https://neuronum.net)
-[![Documentation](https://img.shields.io/badge/Docs-Read%20now-green)](https://github.com/neuronumcybernetics/neuronum)
-[![Tutorials](https://img.shields.io/badge/Tutorials-Watch%20now-red)](https://www.youtube.com/@neuronumnet)
+[![Website](https://img.shields.io/badge/Website-Neuronum-blue)](https://neuronum.net) [![Documentation](https://img.shields.io/badge/Docs-Read%20now-green)](https://github.com/neuronumcybernetics/neuronum)
 
-`Neuronum` is a cybernetic framework enabling businesses to build & automate interconnected networks of soft- and hardware components
+Build, deploy and automate IoT connectivity with `Neuronum`
 
 ## Features
-- **Cell**: Identity to connect and interact with the Neuronum Network
+- **Cells/Cell-CLI**: Create and manage Neuronum Cells from the command line
+- **Nodes/Node-CLI**: Setup and manage Neuronum Nodes from the command line
 - **Transmitters (TX)**: Automate economic data transfer
 - **Circuits (CTX)**: Store data in Key-Value-Label databases
 - **Streams (STX)**: Stream, synchronize and control data in real time
-- **Nodes**: Soft-/Hardware components participating in the Network ecosystem
+- **Contracts/Tokens**: Automate services exchange and authorization between Cells and Nodes
 
-To interact with the Network you will need to create a Neuronum Cell. 
-Create your Cell: [Create Cell](https://neuronum.net/createcell)
+### Installation
+Install the Neuronum library using pip:
+```sh
+$ pip install neuronum
+```
 
+### Cells/Cell-CLI
+To interact with the Neuronum Network, you must first create a Neuronum Cell
 
-### Installation & Connection
-Start with installing the Neuronum library using pip:
-```python
-pip install neuronum
+Create Cell:
+```sh
+$ neuronum create-cell  
 ```
 
-Configure and test Cell connection:
-```python
-import neuronum
+Connect Cell:
+```sh
+$ neuronum connect-cell  
+```
+
+View connected Cell:
+```sh
+$ neuronum view-cell   
+```
+
+Disconnect Cell:
+```sh
+$ neuronum disconnect-cell  
+```
+
+Delete Cell:
+```sh
+$ neuronum delete-cell  
+```
+
+### Nodes/Node-CLI
+Neuronum Nodes are soft- and hardware components that power the Neuronum Network, enabling seamless communication between Nodes and Cells
+
+Initialize a Node:
+```sh
+$ neuronum init-node                                              # neuronum init-node --sync id::stx (optional)  
+```
+
+Start a Node:
+```sh
+$ neuronum start-node   
+```
+
+Stop a Node:
+```sh
+$ neuronum stop-node   
+```
 
-cell = neuronum.Cell(
-host="host::cell",                                                # cell host 
-password="your_password",                                         # cell password 
-network="neuronum.net",                                           # cell network 
-synapse="your_synapse"                                            # cell synapse
-)           
-cell.connect()                                                    # connect to network
+Register a Node on the Neuronum Network:
+```sh
+$ neuronum register-node   
+```
+
+Update a Node:
+```sh
+$ neuronum update-node   
+```
+
+Delete a Node:
+```sh
+$ neuronum delete-node   
 ```
 
 ### Transmitters (TX)
-Transmitters (TX) are used to create predefined templates to receive and send data in a standardized format.
+Transmitters (TX) are used to create predefined templates to receive and send data in a standardized format
 
 Create Transmitter (TX):
 ```python
@@ -87,10 +133,9 @@ TX = "id::tx"                                                     # select Trans
 cell.delete_tx(TX)                                                # delete TX
 ```
 
-List Transmitter (TX) from Cell:
-```python
-cellID = "id::cell"                                               # select Cell
-txList = cell.list_tx(cellID)                                     # list Transmitters (TX)
+List Transmitter (TX) your Cell can activate:
+```python                                            
+txList = cell.list_tx()                                           # list Transmitters (TX)
 ```
 
 ### Circuits (CTX)
@@ -177,10 +222,9 @@ CTX = "id::ctx"                                                   # select Circu
 cell.delete_ctx(CTX)                                              # delete CTX
 ```
 
-List Circuits (CTX) from Cell:
-```python
-cellID = "id::cell"                                               # select Cell
-ctxList = cell.list_ctx(cellID)                                   # list Circuits (CTX)
+List Circuits (CTX) your Cell can interact with:
+```python                                            
+ctxList = cell.list_ctx()                                         # list Circuits (CTX)
 ```
 
 ### Streams (STX)
@@ -243,25 +287,56 @@ for operation in stream:                                          # load stream
     operator = operation.get("operator")
 ```
 
-List Streams (STX) from Cell:
-```python
-cellID = "id::cell"                                               # select Cell
-stxList = cell.list_stx(cellID)                                   # list Streams (STX)
+List Streams (STX) your Cell can interact with:
+```python                                            
+stxList = cell.list_stx()                                         # list Streams (STX)
 ```
 
-### Nodes
-Neuronum Nodes are computing hardware running the Neuronum Client Library, enabling seamless data transmission, synchronization, and facilitating public Stream (STX) access
+### Contracts/Tokens
+Contracts are predefined token-based rules to automate service exchange and authorization between Cells and Nodes
 
-Register a Node with its associated Stream (STX):
+Create a Contract:
 ```python
-descr = "node_name"                                               # description (max 25 characters) 
-mode = "public"                                                   # "public" or "private" Node
-STX = "id::stx"                                                   # select Stream (STX)
-nodeID = cell.register_node(descr, mode, STX)                     # register Node
+descr = "Test Contract"                                           # short description (max 25 characters)
+details = {                                                       # define token details
+    "price_in_eur": False,                                        # token price in EUR (int, float or False)
+    "max_usage": False,                                           # max number of uses (int or False)
+    "validity_in_min": False                                      # token expiration time in min (int, float or False)
+    }          
+partners = ["id::cell", "id::cell"]           
+contractID = cell.create_contract(descr, details, partners)
 ```
 
-Delete Node:
-```python
-nodeID = "id::node"                                               # select Node
-cell.delete_node(nodeID)                                          # delete Node
+Sign a Contract:
+```python         
+contractID = "id::contract"                                       # select contract        
+token = cell.sign_contract(contractID)
+```
+
+Request a Token from another Cell to authorize a service:
+```python         
+cp = "id::cell"                                                   # select counterparty cell
+contractID = "id::contract"                                       # select contract  
+cell.request_token(cp, contractID)
+```
+
+Present a Token to another Cell to authorize a service:
+```python   
+token = "token"                                                   # select token
+cp = "id::cell"                                                   # select counterparty cell
+contractID = "id::contract"                                       # select the contract  
+cell.present_token(token, cp, contractID)
+```
+
+Validate a Token to authorize a service:
+```python   
+token = "token"                                                   # select token
+cp = "id::cell"                                                   # select counterparty cell
+contractID = "id::contract"                                       # select contract  
+cell.validate_token(token, cp, contractID)
+```
+
+List Contracts your Cell can interact with:
+```python                                                     
+contractList = cell.list_contracts()  
 ```

neuronum-1.7.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/main.py,sha256=w4pNMA7ySCKTk4Z-Mb3W7cIw5ZUpLrP92L2HfrcFxSM,17637
+neuronum/__init__.py,sha256=Drsm263_w3_VWgl1YsKLUr8WwVodqV3TSjqpxLjyq_M,46
+neuronum/neuronum.py,sha256=4j3fV7VHPb1KcQucOEDBQ-v2SoG9c2WfGPqMfI3OF88,16498
+neuronum-1.7.0.dist-info/LICENSE,sha256=UiZjNHiCyRP6WoZfbYQh9cv4JW96wIofKXmzBJrYSUk,1125
+neuronum-1.7.0.dist-info/METADATA,sha256=GqgpO0lCzLKJwOfNRH8GzXPbRgsvRvZm3YP5FPVMbNs,12806
+neuronum-1.7.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+neuronum-1.7.0.dist-info/entry_points.txt,sha256=XKYBcRNxGeJpZZkDPsa8HA_RaJ7Km_R_JaUq5T9Nk2U,42
+neuronum-1.7.0.dist-info/top_level.txt,sha256=ru8Fr84cHm6oHr_DcJ8-uaq3RTiuCRFIr6AC8V0zPu4,13
+neuronum-1.7.0.dist-info/RECORD,,

neuronum-1.7.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+neuronum = cli.main:cli

{neuronum-1.5.1.dist-info → neuronum-1.7.0.dist-info}/top_level.txt

@@ -1 +1,2 @@
+cli
 neuronum

neuronum-1.5.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-neuronum/__init__.py,sha256=Drsm263_w3_VWgl1YsKLUr8WwVodqV3TSjqpxLjyq_M,46
-neuronum/neuronum.py,sha256=AL0zXiULx-R-Co4XyYtL0lF-z7GGqXGXDxQEYgithPY,14363
-neuronum-1.5.1.dist-info/LICENSE,sha256=UiZjNHiCyRP6WoZfbYQh9cv4JW96wIofKXmzBJrYSUk,1125
-neuronum-1.5.1.dist-info/METADATA,sha256=H3UZ6u7BHgUcngCTf_0xDwcHjIR1EBlazKe38rXkqnc,11212
-neuronum-1.5.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-neuronum-1.5.1.dist-info/top_level.txt,sha256=73zXVVO9UTTiwEcSaXytsJ8n0q47OCwAqPlIh-hzWJU,9
-neuronum-1.5.1.dist-info/RECORD,,