PyPI - neuronum - Versions diffs - 6.0.0__tar.gz → 7.0.0__tar.gz - Mend

neuronum 6.0.0tar.gz → 7.0.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of neuronum might be problematic. Click here for more details.

Files changed (15) hide show

{neuronum-6.0.0/neuronum.egg-info → neuronum-7.0.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuronum
-Version: 6.0.0
+Version: 7.0.0
 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
@@ -104,102 +105,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 +173,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-6.0.0 → neuronum-7.0.0}/README.md RENAMED Viewed

@@ -71,102 +71,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
@@ -214,6 +139,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-6.0.0 → neuronum-7.0.0}/cli/main.py RENAMED Viewed

@@ -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")
-    if app:
-        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,281 @@ 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
-load_dotenv()
-host = os.getenv("HOST")
-password = os.getenv("PASSWORD")
-network = os.getenv("NETWORK")
-synapse = os.getenv("SYNAPSE")
+            data = {{
+                "json": f"{{operation_id}} - Reply from {nodeID}: Pinged by {{client}} at {{ts}} with data: {{data}}",
+                "html": html_content
+            }}
-cell = neuronum.Cell(
-    host=host,
-    password=password,
-    network=network,
-    synapse=synapse
-)
+            await cell.notify(f"{{client}}", "{nodeID} Ping","Pinged successfully")
-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;
+      }}
+    </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
+You can also interact with this Node by simply visiting this URL in your web browser:
-        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)
+[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 +632,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 +663,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 +752,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 +760,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 +810,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,13 +891,35 @@ async def async_stop_node():
         click.echo("Error: Unable to stop some node processes.")
-@click.command()
 def update_node():
     click.echo("Update your Node")
-    node_type = questionary.select(
-        "Who can view your Node?:",
-        choices=["public", "private", "partners"]
-    ).ask()
+    env_data = {}
+    try:
+        with open(".env", "r") as f:
+            for line in f:
+                key, value = line.strip().split("=")
+                env_data[key] = value
+        host = env_data.get("HOST", "")
+    except FileNotFoundError:
+        click.echo("Error: .env with credentials not found")
+        return
+    except Exception as e:
+        click.echo(f"Error reading .env file: {e}")
+        return
+    if host.startswith("CMTY_"):
+        node_type = questionary.select(
+            "Community Cells can only create private Nodes",
+            choices=["private"]
+        ).ask()
+    else:
+        node_type = questionary.select(
+            "Who can view your Node?:",
+            choices=["public", "private", "partners"]
+        ).ask()
     partners = "None"
     if node_type == "partners":
         prompt_msg = (
@@ -1103,7 +1191,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.0 → neuronum-7.0.0/neuronum.egg-info}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuronum
-Version: 6.0.0
+Version: 7.0.0
 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
@@ -104,102 +105,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 +173,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-6.0.0 → neuronum-7.0.0}/neuronum.egg-info/requires.txt RENAMED Viewed

@@ -5,3 +5,4 @@ questionary
 python-dotenv
 requests
 psutil
+jinja2

{neuronum-6.0.0 → neuronum-7.0.0}/setup.py RENAMED Viewed

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 setup(
     name='neuronum',
-    version='6.0.0',
+    version='7.0.0',
     author='Neuronum Cybernetics',
     author_email='welcome@neuronum.net',
     description='Official client library to interact with the Neuronum Network',
@@ -27,6 +27,7 @@ setup(
         'python-dotenv',
         'requests',
         'psutil',
+        'jinja2',
     ],
     entry_points={
         "console_scripts": [