neuronum 6.0.1__py3-none-any.whl → 7.0.1__py3-none-any.whl

cli/main.py

@@ -249,17 +249,14 @@ def delete_cell():
 
 
 @click.command()
-@click.option('--sync', multiple=True, default=None, help="Optional stream IDs for sync.")
-@click.option('--stream', multiple=True, default=None, help="Optional stream ID for stream.")
-@click.option('--app', is_flag=True, help="Generate a Node with app template")
-def init_node(sync, stream, app):
+def init_node():
     descr = click.prompt("Node description: Type up to 25 characters").strip()
     if descr and len(descr) > 25:
         click.echo("Description too long. Max 25 characters allowed.")
         return
-    asyncio.run(async_init_node(sync, stream, app, descr))
+    asyncio.run(async_init_node(descr))
 
-async def async_init_node(sync, stream, app, descr):
+async def async_init_node(descr):
     credentials_folder_path = Path.home() / ".neuronum"
     env_path = credentials_folder_path / ".env"
 
@@ -308,51 +305,37 @@ async def async_init_node(sync, stream, app, descr):
             click.echo(f"Error sending request: {e}")
             return
 
-    node_filename = "node_" + nodeID.replace("::node", "")
+    node_filename = descr + "_" + nodeID.replace("::node", "")
     project_path = Path(node_filename)
     project_path.mkdir(exist_ok=True)
 
     env_path = project_path / ".env"
     await asyncio.to_thread(env_path.write_text, f"NODE={nodeID}\nHOST={host}\nPASSWORD={password}\nNETWORK={network}\nSYNAPSE={synapse}\n")
-    
-    
-    config_path = project_path / "config.json"
-    await asyncio.to_thread(config_path.write_text, """{                       
-    "data_gateways": [
-        {
-        "type": "stream",
-        "id": "id::stx",
-        "info": "provide a detailed description about the stream"
-        },
-        {
-        "type": "transmitter",
-        "id": "id::tx",
-        "info": "provide a detailed description about the transmitter"
-        },
-        {
-        "type": "circuit",
-        "id": "id::ctx",
-        "info": "provide a detailed description about the circuit"
-        }    
-    ]
-}
-"""
-    )
 
-    nodemd_path = project_path / "NODE.md"
-    await asyncio.to_thread(nodemd_path.write_text, """### NODE.md: Create a detailed Markdown File on how to interact with this Node""")
+    stx_descr = f"{nodeID} App"                                                  
+    partners = ["private"]                                      
+    stxID = await cell.create_stx(stx_descr, partners)  
 
-    stx = sync[0] if sync else (stream[0] if stream else host.replace("::cell", "::stx"))
+    tx_descr = f"Greet {nodeID}"                                           
+    key_values = {                                                          
+        "ping": "pong",
+    }
+    STX = stxID                                                     
+    label = "ping:pong"                                                                                                                                                         
+    partners = ["private"]                                                   
+    txID = await cell.create_tx(tx_descr, key_values, STX, label, partners)
 
-    if sync:
-        for stx in sync:
-            sync_path = project_path / f"sync_{stx.replace('::stx', '')}.py"
-            sync_path.write_text(f"""\
+    app_path = project_path / "app.py"
+    app_path.write_text(f"""\
 import asyncio
 import neuronum
 import os
 from dotenv import load_dotenv
+from jinja2 import Environment, FileSystemLoader                        
 
+env = Environment(loader=FileSystemLoader('.'))
+template = env.get_template('ping.html')                        
+                        
 load_dotenv()
 host = os.getenv("HOST")
 password = os.getenv("PASSWORD")
@@ -366,188 +349,293 @@ cell = neuronum.Cell(
     synapse=synapse
 )
 
-async def main():
-    STX = "{stx}"
-    async for operation in cell.sync(STX):
-        label = operation.get("label")
-        data = operation.get("data")
-        ts = operation.get("time")
-        stxID = operation.get("stxID")
-        operator = operation.get("operator")
-        print(label, data, ts, stxID, operator)
-
-asyncio.run(main())
-""")
+async def main():      
+    STX = "{stxID}"                                          
+    async for operation in cell.sync(STX):       
+        txID = operation.get("txID")
+        client = operation.get("operator")   
+        ts = operation.get("time")  
+        data = operation.get("data") 
+        operation_id = operation.get("operationID")                
+                            
+        if txID == "{txID}":  
+        
+            def render_html_template(client, ts, data, operation_id):
+                return template.render(client=client, ts=ts, data=data, operation_id=operation_id)
 
+            html_content = render_html_template(client, ts, data, operation_id)       
 
-    if stream:
-        for stx in stream:
-            stream_path = project_path / f"stream_{stx.replace('::stx', '')}.py"
-            stream_path.write_text(f"""\
-import asyncio
-import neuronum
-import os
-from dotenv import load_dotenv
-import time                                   
+            data = {{
+                "json": f"{{operation_id}} - Reply from {nodeID}: Pinged by {{client}} at {{ts}} with data: {{data}}",
+                "html": html_content
+            }}
 
-load_dotenv()
-host = os.getenv("HOST")
-password = os.getenv("PASSWORD")
-network = os.getenv("NETWORK")
-synapse = os.getenv("SYNAPSE")
+            await cell.notify(f"{{client}}", "{nodeID} Ping","Pinged successfully")
 
-cell = neuronum.Cell(
-    host=host,
-    password=password,
-    network=network,
-    synapse=synapse
-)
-
-async def main():
-    STX = "{stx}"
-    label = "your_label"
-    
-    while True:
-        data = {{
-            "key1": "value1",
-            "key2": "value2",
-            "key3": "value3",
-        }}
-        await cell.stream(label, data, STX)
-        time.sleep(5) 
+            await cell.tx_response(txID, client, data)
 
 asyncio.run(main())
 """)
     
-    if not sync and not stream and not app:
-        sync_path = project_path / f"sync_{stx.replace('::stx', '')}.py"
-        sync_path.write_text(f"""\
-import asyncio
-import neuronum
-import os
-from dotenv import load_dotenv
+    html_path = project_path / "ping.html"
+    html_content = f"""\
+<!DOCTYPE html>
+<html>
+  <head>
+    <style>
+      body {{
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+        background-color: #121212;
+        color: #e0e0e0;
+        margin: 0;
+        padding: 0;
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        min-height: 100vh;
+      }}
+
+      .container {{
+        background-color: #1e1e1e;
+        border-radius: 12px;
+        padding: 40px;
+        box-shadow: 0 4px 20px rgba(0, 0, 0, 0.5);
+        width: 100%;
+        max-width: 500px;
+        text-align: center;
+        box-sizing: border-box;
+      }}
+
+      .logo {{
+        width: 80px;
+        margin-bottom: 25px;
+        filter: drop-shadow(0 0 5px rgba(255, 255, 255, 0.1));
+      }}
+
+      h1 {{
+        font-size: 1.5em;
+        font-weight: 600;
+        margin-bottom: 5px;
+        color: #f5f5f5;
+      }}
+
+      .subtitle {{
+        font-size: 0.9em;
+        color: #a0a0a0;
+        margin-bottom: 30px;
+      }}
+
+      .data-row {{
+        background-color: #2a2a2a;
+        padding: 12px 15px;
+        border-radius: 8px;
+        margin-bottom: 10px;
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+      }}
+
+      .data-label {{
+        font-weight: 400;
+        color: #a0a0a0;
+        margin: 0;
+      }}
+
+      .data-value {{
+        font-weight: 500;
+        color: #e0e0e0;
+        margin: 0;
+      }}
+
+      .data-value.truncated {{
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        max-width: 60%;
+      }}
+
+      .data-value.client {{
+          color: #8cafff;
+      }}
+      .data-value.timestamp {{
+          color: #a1e8a1;
+      }}
+      .data-value.operation-id {{
+          color: #f7a2a2;
+      }}
+      .api-button {{
+        background: #01c07d 100%;
+        color: white;
+        border: none;
+        border-radius: 8px;
+        padding: 12px 24px;
+        font-size: 16px;
+        font-weight: bold;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+        cursor: pointer;
+        margin-top: 10px;
+      }}
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <img class="logo" src="https://neuronum.net/static/logo.png" alt="Neuronum Logo">
+      
+      <h1>Reply from {nodeID}</h1>
+      <p class="subtitle">Pinged successfully.</p>
+      
+      <div class="data-row">
+        <p class="data-label">Client</p>
+        <p class="data-value client">{{{{client}}}}</p>
+      </div>
+      
+      <div class="data-row">
+        <p class="data-label">Timestamp</p>
+        <p class="data-value timestamp">{{{{ts}}}}</p>
+      </div>
+      
+      <div class="data-row">
+        <p class="data-label">Data</p>
+        <p class="data-value">{{{{data}}}}</p>
+      </div>
+      
+      <div class="data-row">
+        <p class="data-label">Operation ID</p>
+        <p class="data-value operation-id truncated">{{{{operation_id}}}}</p>
+      </div>
+
+      <button id="send-request-btn" class="api-button">Ping again</button>
+    </div>
 
-load_dotenv()
-host = os.getenv("HOST")
-password = os.getenv("PASSWORD")
-network = os.getenv("NETWORK")
-synapse = os.getenv("SYNAPSE")
+    <script>
+    document.getElementById('send-request-btn').addEventListener('click', () => {{
+        const apiEndpoint = 'https://neuronum.net/api/activate/{txID}';
 
-cell = neuronum.Cell(
-    host=host,
-    password=password,
-    network=network,
-    synapse=synapse
+        const dataToSend = {{
+            "data": {{"ping": "node"}},
+            "cell": {{
+                "host": CLIENT_CELL,
+                "session": CLIENT_SESSION, 
+            }}
+        }};
+
+        fetch(apiEndpoint, {{
+            method: 'POST',
+            headers: {{
+                'Content-Type': 'application/json',
+                'Accept': 'application/json'
+            }},
+            body: JSON.stringify(dataToSend)
+        }})
+        .then(response => {{
+            if (!response.ok) {{
+                throw new Error(`HTTP error! status: ${{response.status}}`);
+            }}
+            return response.json();
+        }})
+        .then(data => {{
+            if (data.success && data.response && data.response.html) {{
+                document.open();
+                document.write(data.response.html);
+                document.close();
+                console.log('API Response: Page replaced with new HTML.');
+            }} else {{
+                console.error('API Response does not contain HTML to replace the page:', data);
+                alert('API response error: Expected HTML content to replace the page.');
+            }}
+        }})
+        .catch(error => {{
+            console.error('API request failed:', error);
+            alert('API request failed. See the console for details.');
+        }});
+    }});
+    </script>
+  </body>
+</html>
+"""
+    html_path.write_text(html_content)
+    
+    config_path = project_path / "config.json"
+    await asyncio.to_thread(
+    config_path.write_text,
+f"""{{
+    "app_metadata": {{
+        "name": "{descr}",
+        "version": "1.0.0",
+        "author": "{host}"
+    }},
+    "data_gateways": [
+        {{
+        "type": "transmitter",
+        "id": "{txID}",
+        "info": "Ping Your Node"
+        }}
+    ],
+    "legals": {{
+        "terms_and_conditions": "https://neuronum.net/legals",
+        "data_privacy": "https://neuronum.net/legals"
+    }}
+}}"""
 )
 
-async def main():
-    async for operation in cell.sync():
-        message = operation.get("data").get("message")
-        print(message)
+    nodemd_path = project_path / "NODE.md"
+    await asyncio.to_thread(nodemd_path.write_text, f"""### NODE.md of {nodeID}
 
-asyncio.run(main())
-""")
-        
-        stream_path = project_path / f"stream_{stx.replace('::stx', '')}.py"
-        stream_path.write_text(f"""\
-import asyncio
-import neuronum
-import os
-from dotenv import load_dotenv
-import time                               
+Welcome to your Node's documentation! This guide provides several ways for users to interact with your application.
 
-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
-)
+### 💻 Using the CLI
 
-async def main():
-    label = "Welcome to Neuronum"
-    
-    while True:
-        data = {{
-            "message": "Hello, Neuronum!"
-        }}
-        await cell.stream(label, data)
-        time.sleep(5)                       
+To ping this Node via the command-line interface, use the following command:
 
-asyncio.run(main())
-""")
-        
-    if app and nodeID:
+`neuronum activate --tx {txID} 'ping:node'`
 
-        descr = f"{nodeID} App"                                                  
-        partners = ["private"]                                      
-        stxID = await cell.create_stx(descr, partners)  
+***
 
+### 🌐 Via the Web
 
-        descr = f"Greet {nodeID}"                                           
-        key_values = {                                                          
-            "say": "hello",
-        }
-        STX = stxID                                                     
-        label = "say:hello"                                                                                                                                                         
-        partners = ["private"]                                                   
-        txID = await cell.create_tx(descr, key_values, STX, label, partners)
+You can also interact with this Node by simply visiting this URL in your web browser:
 
+[https://neuronum.net/tx/{txID}](https://neuronum.net/tx/{txID})
 
-        app_path = project_path / "app.py"
-        app_path.write_text(f"""\
+***
+
+### 🐍 With Python
+
+For programmatic access, use the following Python code snippet. This script utilizes the `neuronum` library to activate the transaction and receive a response.
+
+```python
 import asyncio
 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 up Cell connection parameters
 cell = neuronum.Cell(
-    host=host,
-    password=password,
-    network=network,
-    synapse=synapse
+    host="host",                                  # Cell host
+    password="password",                          # Cell password
+    network="neuronum.net",                       # Cell network
+    synapse="synapse"                             # Cell synapse
 )
 
-async def main():      
-    STX = "{stxID}"                                          
-    async for operation in cell.sync(STX):       
-        txID = operation.get("txID")
-        client = operation.get("operator")                    
-                            
-        if txID == "{txID}":             
-            data = {{
-                "json": f"Hello {{client}} from {nodeID}",
-                "html": f\"\"\"
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8">
-    <title>Greeting Node</title>
-  </head>
-  <body>
-    <div class="card">
-      <h1>Hello, {{client}}</h1>
-      <p>Greetings from <span class="node">{nodeID}</span></p>
-    </div>
-  </body>
-</html>
-\"\"\"
-
-            }}
-            await cell.tx_response(txID, client, data)
+async def main():
+    # Define the transaction ID and data payload
+    TX = "{txID}"
+    data = {{"ping": "node"}}
+    
+    # Activate the transaction and get the response
+    tx_response = await cell.activate_tx(TX, data)
+    
+    # Print the response from the Node
+    print(tx_response)
+                                      
+# Run the main asynchronous function
+if __name__ == "__main__":
+    asyncio.run(main())
+```
 
-asyncio.run(main())
+🤖 Via Cellai (Android App - Currently in Testing)
+Download the app from the Google Play Store.
+Send the command "Ping Node" to Cellai
 """)
         
     click.echo(f"Neuronum Node '{nodeID}' initialized!")
@@ -556,6 +644,7 @@ asyncio.run(main())
 @click.command()
 @click.option('--d', is_flag=True, help="Start node in detached mode")
 def start_node(d):
+    update_node()
     pid_file = Path.cwd() / "status.txt"
     system_name = platform.system()
     active_pids = []
@@ -586,27 +675,24 @@ def start_node(d):
     click.echo("Starting Node...")
 
     project_path = Path.cwd()
-    script_files = glob.glob("sync_*.py") + glob.glob("stream_*.py") + glob.glob("app.py")
+    script_files = glob.glob("stream.py") + glob.glob("app.py")
     processes = []
 
     for script in script_files:
         script_path = project_path / script
         if script_path.exists():
-            python_cmd = "pythonw" if system_name == "Windows" else "python"
 
             if d:
                 process = subprocess.Popen(
-                    ["nohup", python_cmd, str(script_path), "&"] if system_name != "Windows"
-                    else [python_cmd, str(script_path)],
+                    ["nohup", sys.executable, str(script_path), "&"] if system_name != "Windows"
+                    else ["pythonw", str(script_path)],
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.DEVNULL,
                     start_new_session=True
                 )
             else:
                 process = subprocess.Popen(
-                    [sys.executable, str(script_path)],
-                    stdout=None,
-                    stderr=None
+                    [sys.executable, str(script_path)]
                 )
 
             processes.append(process.pid)
@@ -678,11 +764,6 @@ def check_node():
                 continue
 
     if running_pids:
-        for pid in running_pids:
-                proc = psutil.Process(pid)
-                mem = proc.memory_info().rss / (1024 * 1024)  # in MB
-                cpu = proc.cpu_percent(interval=0.1)
-                click.echo(f"PID {pid} → Memory: {mem:.2f} MB | CPU: {cpu:.1f}%")
         click.echo(f"Node {nodeID} is running. Active PIDs: {', '.join(map(str, running_pids))}")
     else:
         click.echo(f"Node {nodeID} is not running.")
@@ -691,6 +772,7 @@ def check_node():
 @click.command()
 @click.option('--d', is_flag=True, help="Restart node in detached mode")
 def restart_node(d):
+    update_node()
     pid_file = Path.cwd() / "status.txt"
     system_name = platform.system()
 
@@ -740,27 +822,23 @@ def restart_node(d):
 
     click.echo(f"Starting Node {nodeID}...")
     project_path = Path.cwd()
-    script_files = glob.glob("sync_*.py") + glob.glob("stream_*.py") + glob.glob("app.py")
+    script_files = glob.glob("stream.py") + glob.glob("app.py")
     processes = []
 
-    python_cmd = "pythonw" if system_name == "Windows" else "python"
-
     for script in script_files:
         script_path = project_path / script
         if script_path.exists():
             if d:
                 process = subprocess.Popen(
-                    ["nohup", python_cmd, str(script_path), "&"] if system_name != "Windows"
-                    else [python_cmd, str(script_path)],
+                    ["nohup", sys.executable, str(script_path), "&"] if system_name != "Windows"
+                    else ["pythonw", str(script_path)],
                     stdout=subprocess.DEVNULL,
                     stderr=subprocess.DEVNULL,
                     start_new_session=True
                 )
             else:
                 process = subprocess.Popen(
-                    [sys.executable, str(script_path)],
-                    stdout=None,
-                    stderr=None
+                    [sys.executable, str(script_path)]
                 )
 
             processes.append(process.pid)
@@ -825,7 +903,6 @@ async def async_stop_node():
         click.echo("Error: Unable to stop some node processes.")
 
 
-@click.command()
 def update_node():
     click.echo("Update your Node")
     env_data = {}
@@ -1126,7 +1203,6 @@ cli.add_command(start_node)
 cli.add_command(restart_node)
 cli.add_command(stop_node)
 cli.add_command(check_node)
-cli.add_command(update_node)
 cli.add_command(delete_node)
 cli.add_command(activate)
 cli.add_command(load)

{neuronum-6.0.1.dist-info → neuronum-7.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuronum
-Version: 6.0.1
+Version: 7.0.1
 Summary: Official client library to interact with the Neuronum Network
 Home-page: https://neuronum.net
 Author: Neuronum Cybernetics
@@ -19,6 +19,7 @@ Requires-Dist: questionary
 Requires-Dist: python-dotenv
 Requires-Dist: requests
 Requires-Dist: psutil
+Requires-Dist: jinja2
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -78,7 +79,6 @@ Neuronum is the real-time data engine designed for developers to build event-dri
 
 ### Requirements
 - Python >= 3.8
-- neuronum >= 5.5.0
 
 ------------------
 
@@ -104,102 +104,27 @@ neuronum connect-cell                   # connect Cell
 
 
 ### **Build On Neuronum** 
-To dive deeper into Neuronum App development, visit & build with [Node Examples](https://github.com/neuronumcybernetics/neuronum/tree/main/features/nodes/examples)
+Visit & build with [Node Examples](https://github.com/neuronumcybernetics/neuronum/tree/main/features/nodes/examples) to gain deeper knowledge on how to build on Neuronum.
 
-Initialize a Node (app template):
+To get started, initialize a new Node with the command below. 
 ```sh
-neuronum init-node --app                # initialize a Node with app template
+neuronum init-node
 ```
 
-This command prompts you to enter a Node description (e.g Test App) and creates a new directory named node_<node_id> containing the following files:
+This command will prompt you for a description (e.g., Test App) and will create
 
-.env
-```env
-NODE=your_node_id
-HOST=your_cell_id
-PASSWORD=your_password
-NETWORK=neuronum.net
-SYNAPSE=your_synapse                    # auth token
-```
+1. A Stream (STX) so your App can receive requests, and a Transmitter (TX) to match those requests
+2. A new directory named "Test App_<your_node_id>" with the following files
 
-app.py
-```python
-import asyncio
-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
-)
+.env: Stores your Node's credentials for connecting to the network.
 
-async def main():      
-    STX = "id::stx"                                          
-    async for operation in cell.sync(STX):       
-        txID = operation.get("txID")
-        client = operation.get("operator")                    
-                            
-        if txID == "id::tx":             
-            data = {
-                "json": f"Hello {client}",
-                "html": f"""
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8">
-    <title>Greeting Node</title>
-  </head>
-  <body>
-    <div class="card">
-      <h1>Hello, {client}</h1>
-    </div>
-  </body>
-</html>
-"""
-
-            }
-            await cell.tx_response(txID, client, data)
+app.py: The main Python script that contains your Node's core logic.
 
-asyncio.run(main())
-```
-
-config.json (required if you want to make your app accessible to Cellai (currently in testing))
-```json
-{                       
-    "data_gateways": [
-        {
-        "type": "stream",
-        "id": "id::stx",
-        "info": "provide a detailed description about the stream"
-        },
-        {
-        "type": "transmitter",
-        "id": "id::tx",
-        "info": "provide a detailed description about the transmitter"
-        },
-        {
-        "type": "circuit",
-        "id": "id::ctx",
-        "info": "provide a detailed description about the circuit"
-        }
-    ]
-}
-```
+NODE.md: Public documentation that provides instructions for interacting with your Node.
 
-NODE.md (required if you want to publish your App)
-```
-### NODE.md: Create a detailed Markdown File on how to interact with this Node
-```
+config.json: A configuration file that stores metadata about your app and enables Cellai to interact with your Node's data gateways.
 
+ping.html: A static HTML file used to render web-based responses.
 
 Change into Node folder
 ```sh
@@ -247,6 +172,6 @@ asyncio.run(main())
 neuronum activate --tx id::tx 'say:hello'
 ```
 
-#### **Cellai**
-Cellai is a mobile interface that lets you interact with Neuronum apps using natural language. It is currently in testing.
+#### **Cellai (in Testing)**
+Cellai is an AI tool for developers to test their apps built on Neuronum and will soon be published to the Google Play Store.
 

neuronum-7.0.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/main.py,sha256=nOoWfn7zdukLZQuGYx-47nINMZVSdPbcdMuu0bDCKzM,36520
+neuronum/__init__.py,sha256=tAdqNC9rByY_CwG63yAyEe34phBdQ_Vv3FyFpTXQ2wo,45
+neuronum/neuronum.py,sha256=5OjJIAmY7haT6eJ3P767RFk-LTvNFRrlkjB9mOozgN8,17971
+neuronum-7.0.1.dist-info/licenses/LICENSE.md,sha256=m7pw_FktMNCs4tcy2UXP3QQP2S_je28P1SepdYoo0Xo,1961
+neuronum-7.0.1.dist-info/METADATA,sha256=ymaVKlx87rwW30nBkXE-wxgPRo8KaI9cfjkV4etqZGM,6098
+neuronum-7.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+neuronum-7.0.1.dist-info/entry_points.txt,sha256=XKYBcRNxGeJpZZkDPsa8HA_RaJ7Km_R_JaUq5T9Nk2U,42
+neuronum-7.0.1.dist-info/top_level.txt,sha256=ru8Fr84cHm6oHr_DcJ8-uaq3RTiuCRFIr6AC8V0zPu4,13
+neuronum-7.0.1.dist-info/RECORD,,

neuronum-6.0.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cli/main.py,sha256=gQ5AE9JwsQQf60jJEwXnHsNWZg0wlSv3PCTuGK4WS4I,33971
-neuronum/__init__.py,sha256=tAdqNC9rByY_CwG63yAyEe34phBdQ_Vv3FyFpTXQ2wo,45
-neuronum/neuronum.py,sha256=5OjJIAmY7haT6eJ3P767RFk-LTvNFRrlkjB9mOozgN8,17971
-neuronum-6.0.1.dist-info/licenses/LICENSE.md,sha256=m7pw_FktMNCs4tcy2UXP3QQP2S_je28P1SepdYoo0Xo,1961
-neuronum-6.0.1.dist-info/METADATA,sha256=N91j-LoSDy3ovC8V09yNwxEFCAFrEDLQjYfAfkZeVB0,7467
-neuronum-6.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-neuronum-6.0.1.dist-info/entry_points.txt,sha256=XKYBcRNxGeJpZZkDPsa8HA_RaJ7Km_R_JaUq5T9Nk2U,42
-neuronum-6.0.1.dist-info/top_level.txt,sha256=ru8Fr84cHm6oHr_DcJ8-uaq3RTiuCRFIr6AC8V0zPu4,13
-neuronum-6.0.1.dist-info/RECORD,,