neuronum 1.5.1__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

@@ -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.1.dist-info → neuronum-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: neuronum
-Version: 1.5.1
+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,33 +14,36 @@ 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
 
 ## Features
 - **Cell**: Identity to connect and interact with the Neuronum Network
+- **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)
 
-
-### Installation & Connection
-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
 
@@ -53,6 +56,39 @@ synapse="your_synapse"                                            # cell synapse
 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.
 
@@ -87,10 +123,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 +212,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 +277,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 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.1.dist-info → neuronum-1.6.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,,