neuronum 1.5.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

cli/main.py

@@ -0,0 +1,341 @@
+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 init_node():
+    click.echo("Initialize Node")
+
+    node_type = questionary.select(
+        "Choose Node type:",
+        choices=["public", "private"]
+    ).ask()
+
+    descr = click.prompt("Node description (max. 25 characters)")
+    host = click.prompt("Enter your cell host")
+    password = click.prompt("Enter your password", hide_input=True)
+    network = click.prompt("Enter your network")
+    synapse = click.prompt("Enter your synapse", hide_input=True)
+
+    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"
+    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")
+
+    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("""\
+#some markdown                             
+""")
+        
+    main_path = project_path / "main.py"
+    main_path.write_text("""\
+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")                    
+
+#set cell connection
+cell = neuronum.Cell(
+host=host,
+password=password,
+network=network,
+synapse=synapse
+)
+
+STX = "n9gW3LxQcecI::stx"
+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("Neuronum Node started successfully!")
+
+
+@click.command()
+def stop_node():
+    """Stops the Neuronum node"""
+    click.echo("Stopping Neuronum 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("Neuronum 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():
+    click.echo("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():
+    click.echo("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():
+    click.echo("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(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

@@ -32,13 +32,13 @@ class Cell:
         return "Authentication successful" in response
     
 
-    def create_tx(self, descr: str, key_values: dict, ctx: str, label: str, partners: list):
+    def create_tx(self, descr: str, key_values: dict, stx: str, label: str, partners: list):
         url = f"https://{self.network}/api/create_tx"
 
         TX = {
             "descr": descr,
             "key_values": key_values,
-            "ctx": ctx,
+            "stx": stx,
             "label": label,
             "partners": partners,
             "cell": self.to_dict()
@@ -206,108 +206,51 @@ 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:
@@ -459,14 +402,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 +416,150 @@ 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.0.dist-info → neuronum-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: neuronum
-Version: 1.5.0
+Version: 1.6.0
 Summary: Interact with the Neuronum Network to build & automate interconnected networks of soft- and hardware components
 Home-page: https://neuronum.net
 Author: Neuronum Cybernetics
@@ -14,172 +14,207 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests
 Requires-Dist: websocket-client
-Requires-Dist: iota-sdk
+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
 
 ## Features
 - **Cell**: Identity to connect and interact with the Neuronum Network
-- **Transmitters (TX)**: Automate economic data transfer and storage
-- **Circuits (CTX)**: Store data in a Key-Value-Label database
+- **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 contract-based authorization between Nodes and Cells
 
-To interact with the Network you will need to create a Neuronum Cell. 
-Create your Cell: [Create Cell](https://neuronum.net/createcell)
 
-Start with installing the Neuronum library using pip:
+### Installation
+Install the Neuronum library using pip:
 ```python
 pip install neuronum
 ```
 
-Configure and test Cell connection:
+### Cell
+To interact with the Network you will need to create a Neuronum Cell. 
+Create your Cell: [Create Cell](https://neuronum.net/createcell)
+
+Set and test Cell connection:
 ```python
 import neuronum
 
 cell = neuronum.Cell(
-host="host::cell",                                                      # cell host 
-password="your_password",                                               # cell password 
-network="neuronum.net",                                                 # cell network 
-synapse="your_synapse"                                                  # cell synapse
+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
+cell.connect()                                                    # connect to network
+```
+
+### Nodes/Node-CLI
+Neuronum Nodes are computing hardware powered by the Neuronum library, enabling seamless communication between Nodes and Cells.
+
+Initialize your Node:
+```bash
+>>> neuronum init-node   
+```
+
+Start your Node:
+```bash
+>>> neuronum start-node   
+```
+
+Stop your Node:
+```bash
+>>> neuronum stop-node   
+```
+
+Register your Node on the Neuronum Network:
+```bash
+>>> neuronum register-node   
+```
+
+Update your Node:
+```bash
+>>> neuronum update-node   
+```
+
+Delete your Node:
+```bash
+>>> neuronum delete-node   
 ```
 
 ### Transmitters (TX)
-Transmitters (TX) are used to create predefined templates to receive and send data in a standardized format. Data sent with TX is always and automatically stored in a predefined Circuit (CTX)
+Transmitters (TX) are used to create predefined templates to receive and send data in a standardized format.
 
 Create Transmitter (TX):
 ```python
-descr = "Test Transmitter"                                              # description (max 25 characters)
-key_values = {                                                          # defined keys and example values
+descr = "Test Transmitter"                                        # description (max 25 characters)
+key_values = {                                                    # defined keys and example values
     "key1": "value1",
     "key2": "value2",
     "key3": "value3",
 }
-ctx = "id::ctx"                                                         # select Circuit (CTX)
-label = "key1:key2"                                                     # label TX data
-partners = ["id::cell", "id::cell"]                                     # authorized Cells
-txID = cell.create_tx(descr, key_values, ctx, label, partners) 
+stx = "id::stx"                                                   # select Stream (STX)
+label = "key1:key2"                                               # label TX data
+partners = ["id::cell", "id::cell"]                               # authorized Cells
+txID = cell.create_tx(descr, key_values, stx, label, partners)    # create TX
 ```
 
 Activate Transmitter (TX):
 ```python
-TX = "id::tx"                                                           # select Transmitter (TX)
-data = {                                                                # enter key-values
+TX = "id::tx"                                                     # select Transmitter (TX)
+data = {                                                          # enter key-values
     "key1": "value1",
     "key2": "value2",
     "key3": "value3",
 }
-cell.activate_tx(TX, data)                                              # activate TX
+cell.activate_tx(TX, data)                                        # activate TX
 ```
 
 Delete Transmitter (TX):
 ```python
-TX = "id::tx"                                                           # select Transmitter (TX)
-cell.delete_tx(TX)                                                      # delete TX
+TX = "id::tx"                                                     # select Transmitter (TX)
+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)
-Circuits (CTX) store and organize data sent via Transmitters (TX) using a Key-Value-Label system
+Circuits (CTX) store and organize data using a Key-Value-Label system
 
 Create Circuit (CTX):
 ```python
-descr = "Test Circuit"                                                  # description (max 25 characters) 
-partners = ["id::cell", "id::cell"]                                     # authorized Cells
-ctxID = cell.create_ctx(descr, partners)                                # create Circuit (CTX)
+descr = "Test Circuit"                                            # description (max 25 characters) 
+partners = ["id::cell", "id::cell"]                               # authorized Cells
+ctxID = cell.create_ctx(descr, partners)                          # create Circuit (CTX)
 ```
 
 Store data on your private Circuit (CTX):
 ```python
-label = "your_label"                                                    # data label (should be unique)
-data = {                                                                # data as key-value pairs
+label = "your_label"                                              # data label (should be unique)
+data = {                                                          # data as key-value pairs
     "key1": "value1",
     "key2": "value2",
     "key3": "value3",
 }
-cell.store(label, data)                                                 # store data
+cell.store(label, data)                                           # store data
 ```
 
 Store data on a public Circuit (CTX):
 ```python
-CTX = "id::ctx"                                                         # select Circuit (CTX
-label = "your_label"                                                    # data label (should be unique)
-data = {                                                                # data as key-value pairs
+CTX = "id::ctx"                                                   # select Circuit (CTX
+label = "your_label"                                              # data label (should be unique)
+data = {                                                          # data as key-value pairs
     "key1": "value1",
     "key2": "value2",
     "key3": "value3",
 }
-cell.store(label, data, CTX)                                            # store data
+cell.store(label, data, CTX)                                      # store data
 ```
 
 Load data from your private Circuit (CTX):
 ```python
-label = "your_label"                                                    # select label
-data = cell.load(label)                                                 # load data by label
-key1 = data["key1"]                                                     # get data from key
+label = "your_label"                                              # select label
+data = cell.load(label)                                           # load data by label
+key1 = data["key1"]                                               # get data from key
 key2 = data["key2"]
 key3 = data["key3"]
-print(key1, key2, key3)                                                 # print data
+print(key1, key2, key3)                                           # print data
 ```
 
 Load data from a public Circuit (CTX):
 ```python
-CTX = "id::ctx"                                                         # select Circuit (CTX)
-label = "your_label"                                                    # select label
-data = cell.load(label, CTX)                                            # load data by label
-key1 = data["key1"]                                                     # get data from key
+CTX = "id::ctx"                                                   # select Circuit (CTX)
+label = "your_label"                                              # select label
+data = cell.load(label, CTX)                                      # load data by label
+key1 = data["key1"]                                               # get data from key
 key2 = data["key2"]
 key3 = data["key3"]
-print(key1, key2, key3)                                                 # print data
+print(key1, key2, key3)                                           # print data
 ```
 
 Delete data from your private Circuit (CTX):
 ```python
-label = "your_label"                                                    # select label
-cell.delete(label)                                                      # delete data by label
+label = "your_label"                                              # select label
+cell.delete(label)                                                # delete data by label
 ```
 
 Delete data from a public Circuit (CTX):
 ```python
-CTX = "id::ctx"                                                         # select Circuits (CTX)
-label = "your_label"                                                    # select label
-cell.delete(label, CTX)                                                 # delete data by label
+CTX = "id::ctx"                                                   # select Circuits (CTX)
+label = "your_label"                                              # select label
+cell.delete(label, CTX)                                           # delete data by label
 ```
 
 Clear your private Circuit (CTX):
 ```python
-cell.clear()                                                            # clear Circuit (CTX)
+cell.clear()                                                      # clear Circuit (CTX)
 ```
 
 Clear Circuit (CTX):
 ```python
-CTX = "id::ctx"                                                         # select Circuit (CTX)
-cell.clear(CTX)                                                         # clear CTX
+CTX = "id::ctx"                                                   # select Circuit (CTX)
+cell.clear(CTX)                                                   # clear CTX
 ```
 
 Delete Circuit (CTX):
 ```python
-CTX = "id::ctx"                                                         # select Circuit (CTX)
-cell.delete_ctx(CTX)                                                    # delete CTX
+CTX = "id::ctx"                                                   # select Circuit (CTX)
+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)
@@ -187,39 +222,39 @@ Streams (STX) facilitate real-time data synchronization and interaction, ensurin
 
 Create Stream (STX):
 ```python
-descr = "Test Stream"                                                   # description (max 25 characters) 
-partners = ["id::cell", "id::cell"]                                     # authorized Cells
-stxID = cell.create_stx(descr, partners)                                # create Stream (STX)
+descr = "Test Stream"                                             # description (max 25 characters) 
+partners = ["id::cell", "id::cell"]                               # authorized Cells
+stxID = cell.create_stx(descr, partners)                          # create Stream (STX)
 ```
 
 Stream data to your private Stream (STX):
 ```python
-label = "your_label"                                                    # data label
-data = {                                                                # data as key-value pairs
+label = "your_label"                                              # data label
+data = {                                                          # data as key-value pairs
     "key1": "value1",
     "key2": "value2",
     "key3": "value3",
 }
-cell.stream(label, data)                                                # stream data
+cell.stream(label, data)                                          # stream data
 ```
 
 Stream data to a public Stream (STX):
 ```python
-STX = "id::stx"                                                         # select Stream (STX)
-label = "your_label"                                                    # data label
-data = {                                                                # data as key-value pairs
+STX = "id::stx"                                                   # select Stream (STX)
+label = "your_label"                                              # data label
+data = {                                                          # data as key-value pairs
     "key1": "value1",
     "key2": "value2",
     "key3": "value3",
 }
-cell.stream(label, data, STX)                                           # stream data
+cell.stream(label, data, STX)                                     # stream data
 ```
 
 Sync data from your private Stream (STX):
 ```python
-stream = cell.sync()                                                    # synchronize Stream (STX)
-for operation in stream:                                                # load stream operations
-    label = operation.get("label")                                      # get the operation details by key
+stream = cell.sync()                                              # synchronize Stream (STX)
+for operation in stream:                                          # load stream operations
+    label = operation.get("label")                                # get the operation details by key
     key1 = operation.get("data").get("key1")
     key2 = operation.get("data").get("key2")
     key3 = operation.get("data").get("key3")
@@ -230,10 +265,10 @@ for operation in stream:                                                # load s
 
 Sync data from a public Stream (STX):
 ```python
-STX = "id::stx"                                                         # select Stream (STX)  
-stream = cell.sync(STX)                                                 # synchronize Stream (STX)
-for operation in stream:                                                # load stream operations
-    label = operation.get("label")                                      # get the operation details by key
+STX = "id::stx"                                                   # select Stream (STX)  
+stream = cell.sync(STX)                                           # synchronize Stream (STX)
+for operation in stream:                                          # load stream operations
+    label = operation.get("label")                                # get the operation details by key
     key1 = operation.get("data").get("key1")
     key2 = operation.get("data").get("key2")
     key3 = operation.get("data").get("key3")
@@ -242,25 +277,56 @@ for operation in stream:                                                # load s
     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 define rules for authorization, allowing users to sign and generate unique tokens for secure access
 
-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": 10,                                           # token price in EUR
+    "max_usage": 10,                                              # max number of uses
+    "validity_in_min": 10                                         # token expiration time (minutes)
+    }          
+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.6.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/main.py,sha256=wD5wj2qy-VKwrx9CWoHbxmERSO1Z11B59oMJc49GM9E,9449
+neuronum/__init__.py,sha256=Drsm263_w3_VWgl1YsKLUr8WwVodqV3TSjqpxLjyq_M,46
+neuronum/neuronum.py,sha256=qJqYpVoKdUw0YOa7aMp85QSOflkn8R7sqF5dIlTkBe0,16993
+neuronum-1.6.0.dist-info/LICENSE,sha256=UiZjNHiCyRP6WoZfbYQh9cv4JW96wIofKXmzBJrYSUk,1125
+neuronum-1.6.0.dist-info/METADATA,sha256=BblXzU3CeyyrTzdEyj0K--RnillyBYhNi-61mao50HA,13089
+neuronum-1.6.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+neuronum-1.6.0.dist-info/entry_points.txt,sha256=XKYBcRNxGeJpZZkDPsa8HA_RaJ7Km_R_JaUq5T9Nk2U,42
+neuronum-1.6.0.dist-info/top_level.txt,sha256=ru8Fr84cHm6oHr_DcJ8-uaq3RTiuCRFIr6AC8V0zPu4,13
+neuronum-1.6.0.dist-info/RECORD,,

neuronum-1.6.0.dist-info/entry_points.txt

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

{neuronum-1.5.0.dist-info → neuronum-1.6.0.dist-info}/top_level.txt

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

neuronum-1.5.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-neuronum/__init__.py,sha256=Drsm263_w3_VWgl1YsKLUr8WwVodqV3TSjqpxLjyq_M,46
-neuronum/neuronum.py,sha256=BymDHznUPI3mD09mquEbVODFMWiBaxNHYOst4-qDxZ8,14363
-neuronum-1.5.0.dist-info/LICENSE,sha256=UiZjNHiCyRP6WoZfbYQh9cv4JW96wIofKXmzBJrYSUk,1125
-neuronum-1.5.0.dist-info/METADATA,sha256=9s6uAwEgWSVAM0FwIwayvuskht2myPMUeGXEMgxV8ew,11764
-neuronum-1.5.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-neuronum-1.5.0.dist-info/top_level.txt,sha256=73zXVVO9UTTiwEcSaXytsJ8n0q47OCwAqPlIh-hzWJU,9
-neuronum-1.5.0.dist-info/RECORD,,