neuronum 3.0.2__tar.gz → 4.0.0__tar.gz

neuronum-4.0.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: neuronum
+Version: 4.0.0
+Summary: Official client library to interact with the Neuronum Network
+Home-page: https://neuronum.net
+Author: Neuronum Cybernetics
+Author-email: welcome@neuronum.net
+Project-URL: GitHub, https://github.com/neuronumcybernetics/neuronum
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: websockets
+Requires-Dist: click
+Requires-Dist: questionary
+Requires-Dist: python-dotenv
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+![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)
+
+
+### **Getting Started Goals**
+- Learn about Neuronum
+- Connect to Neuronum
+- Build on Neuronum
+
+
+### **About Neuronum**
+Neuronum is a central serverless data gateway automating the processing and distribution of data transmission, storage, and streaming.
+In practice, Neuronum forms an interconnected network of soft- and hardware components (Nodes) exchanging data in real time.
+
+
+### **Network Attributes**
+**Cell & Nodes**
+- Cell: Account to connect and interact with the Neuronum Network
+- Nodes: Software and Hardware components connected to Neuronum
+
+**Data Gateways**
+- Transmitters (TX): Automate data transfer in standardized formats
+- Circuits (CTX): Store data in cloud-based key-value-label databases
+- Streams (STX): Stream, synchronize, and control data in real time
+
+
+#### Requirements
+- Python >= 3.8 -> https://www.python.org/downloads/
+- neuronum >= 4.0.0 -> https://pypi.org/project/neuronum/
+
+
+------------------
+
+
+### **Connect to Neuronum**
+Installation
+```sh
+pip install neuronum                    # install neuronum dependencies
+```
+
+Create Cell:
+```sh
+neuronum create-cell                    # create Cell / Cell type / Cell network 
+```
+
+Connect Cell:
+```sh
+neuronum connect-cell                   # connect Cell
+```
+
+View connected Cell:
+```sh
+neuronum view-cell                      # view Cell / output = Connected Cell: 'your_cell'"
+```
+
+Disconnect Cell:
+```sh
+neuronum disconnect-cell                # disconnect Cell
+```
+
+Delete Cell:
+```sh
+neuronum delete-cell                    # delete Cell
+```
+
+
+------------------
+
+
+
+### **Build on Neuronum**
+Initialize Node (default template):
+```sh
+neuronum init-node                      # initialize a Node with default template
+```
+
+Initialize Node (stream template):
+```sh
+neuronum init-node --stream id::stx     # initialize a Node with stream template
+```
+
+Initialize Node (sync template):
+```sh
+neuronum init-node --sync id::stx       # initialize a Node with sync template
+```
+
+cd to Node folder:
+```sh
+cd node_node_id                         # change to Node folder
+```
+
+Start Node:
+```sh
+neuronum start-node                     # start Node
+```
+
+Start Node (detached mode):
+```sh
+neuronum start-node --d                 # start Node in "detached" mode
+```
+
+Stop Node:
+```sh
+neuronum stop-node                      # stop Node
+```
+
+Connect Node:
+```sh
+neuronum connect-node                   # connect your Node / Node type / Node description
+```
+
+Update Node:
+```sh
+neuronum update-node                    # update your Node
+```
+
+Disconnect Node:
+```sh
+neuronum disconnect-node                # disconnect your Node
+```
+
+Delete Node:
+```sh
+neuronum delete-node                    # delete your Node
+```

neuronum-4.0.0/README.md

@@ -0,0 +1,126 @@
+![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)
+
+
+### **Getting Started Goals**
+- Learn about Neuronum
+- Connect to Neuronum
+- Build on Neuronum
+
+
+### **About Neuronum**
+Neuronum is a central serverless data gateway automating the processing and distribution of data transmission, storage, and streaming.
+In practice, Neuronum forms an interconnected network of soft- and hardware components (Nodes) exchanging data in real time.
+
+
+### **Network Attributes**
+**Cell & Nodes**
+- Cell: Account to connect and interact with the Neuronum Network
+- Nodes: Software and Hardware components connected to Neuronum
+
+**Data Gateways**
+- Transmitters (TX): Automate data transfer in standardized formats
+- Circuits (CTX): Store data in cloud-based key-value-label databases
+- Streams (STX): Stream, synchronize, and control data in real time
+
+
+#### Requirements
+- Python >= 3.8 -> https://www.python.org/downloads/
+- neuronum >= 4.0.0 -> https://pypi.org/project/neuronum/
+
+
+------------------
+
+
+### **Connect to Neuronum**
+Installation
+```sh
+pip install neuronum                    # install neuronum dependencies
+```
+
+Create Cell:
+```sh
+neuronum create-cell                    # create Cell / Cell type / Cell network 
+```
+
+Connect Cell:
+```sh
+neuronum connect-cell                   # connect Cell
+```
+
+View connected Cell:
+```sh
+neuronum view-cell                      # view Cell / output = Connected Cell: 'your_cell'"
+```
+
+Disconnect Cell:
+```sh
+neuronum disconnect-cell                # disconnect Cell
+```
+
+Delete Cell:
+```sh
+neuronum delete-cell                    # delete Cell
+```
+
+
+------------------
+
+
+
+### **Build on Neuronum**
+Initialize Node (default template):
+```sh
+neuronum init-node                      # initialize a Node with default template
+```
+
+Initialize Node (stream template):
+```sh
+neuronum init-node --stream id::stx     # initialize a Node with stream template
+```
+
+Initialize Node (sync template):
+```sh
+neuronum init-node --sync id::stx       # initialize a Node with sync template
+```
+
+cd to Node folder:
+```sh
+cd node_node_id                         # change to Node folder
+```
+
+Start Node:
+```sh
+neuronum start-node                     # start Node
+```
+
+Start Node (detached mode):
+```sh
+neuronum start-node --d                 # start Node in "detached" mode
+```
+
+Stop Node:
+```sh
+neuronum stop-node                      # stop Node
+```
+
+Connect Node:
+```sh
+neuronum connect-node                   # connect your Node / Node type / Node description
+```
+
+Update Node:
+```sh
+neuronum update-node                    # update your Node
+```
+
+Disconnect Node:
+```sh
+neuronum disconnect-node                # disconnect your Node
+```
+
+Delete Node:
+```sh
+neuronum delete-node                    # delete your Node
+```

{neuronum-3.0.2 → neuronum-4.0.0}/cli/main.py

@@ -304,14 +304,12 @@ async def async_init_node(sync, stream):
     tx = await cell.list_tx()
     ctx = await cell.list_ctx()
     stx = await cell.list_stx()
-    contracts = await cell.list_contracts()
     nodes = await cell.list_nodes()
 
     await asyncio.to_thread((project_path / "cells.json").write_text, json.dumps(cells, indent=4))
     await asyncio.to_thread((project_path / "transmitters.json").write_text, json.dumps(tx, indent=4))
     await asyncio.to_thread((project_path / "circuits.json").write_text, json.dumps(ctx, indent=4))
     await asyncio.to_thread((project_path / "streams.json").write_text, json.dumps(stx, indent=4))
-    await asyncio.to_thread((project_path / "contracts.json").write_text, json.dumps(contracts, indent=4))
     await asyncio.to_thread((project_path / "nodes.json").write_text, json.dumps(nodes, indent=4))
 
     env_path = project_path / ".env"
@@ -334,8 +332,8 @@ async def async_init_node(sync, stream):
             "link": "https://www.python.org/downloads/"
         },
         {
-            "name": "Neuronum Lib",
-            "version": ">= 3.0.1",
+            "name": "neuronum",
+            "version": ">= 4.0.0",
             "link": "https://pypi.org/project/neuronum/"
         }
     ],
@@ -483,57 +481,36 @@ async def main():
 asyncio.run(main())
 """)
         
-    scan_path = project_path / f"scan.py"
-    scan_path.write_text(f"""\
-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
-)
-
-async def main():
-    async for cp in cell.scan():
-        print(cp)
-
-asyncio.run(main())
-""")
-
     click.echo(f"Neuronum Node '{nodeID}' initialized!")
 
 
 @click.command()
-def start_node():
-    scan_type = questionary.select(
-        "Scan for Neuronum Cells and Nodes (Ensure Bluetooth is enabled)",
-        choices=["On", "Off"]
-    ).ask()
-
+@click.option('--d', is_flag=True, help="Start node in detached mode")
+def start_node(d):
     click.echo("Starting Node...")
 
     project_path = Path.cwd()
     script_files = glob.glob("sync_*.py") + glob.glob("stream_*.py")
 
-    if scan_type == "On":
-        script_files += glob.glob("scan.py")
-
     processes = []
+    system_name = platform.system()
 
     for script in script_files:
         script_path = project_path / script
         if script_path.exists():
-            process = subprocess.Popen(["python", str(script_path)], start_new_session=True)
+            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)],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    start_new_session=True
+                )
+            else:
+                process = subprocess.Popen(["python", str(script_path)], start_new_session=True)
+
             processes.append(process.pid)
 
     if not processes:
@@ -546,7 +523,6 @@ def start_node():
     click.echo("Node started successfully!")
 
 
-
 @click.command()
 def stop_node():
     asyncio.run(async_stop_node())
@@ -720,14 +696,12 @@ async def async_update_node():
     tx = await cell.list_tx()
     ctx = await cell.list_ctx()
     stx = await cell.list_stx()
-    contracts = await cell.list_contracts()
     nodes = await cell.list_nodes()
 
     await asyncio.to_thread(Path("cells.json").write_text, json.dumps(cells, indent=4))
     await asyncio.to_thread(Path("transmitters.json").write_text, json.dumps(tx, indent=4))
     await asyncio.to_thread(Path("circuits.json").write_text, json.dumps(ctx, indent=4))
     await asyncio.to_thread(Path("streams.json").write_text, json.dumps(stx, indent=4))
-    await asyncio.to_thread(Path("contracts.json").write_text, json.dumps(contracts, indent=4))
     await asyncio.to_thread(Path("nodes.json").write_text, json.dumps(nodes, indent=4))
 
     click.echo(f"Neuronum Node '{nodeID}' updated! Visit: {node_url}")
@@ -827,16 +801,6 @@ async def async_delete_node():
     click.echo(f"Neuronum Node '{nodeID}' deleted!")
 
 
-
-@click.command() 
-def call_cellai(): 
-    try: 
-        from cellai import cellai 
-        cellai.main() 
-    except ImportError: 
-        click.echo("Cellai not found. Please check the necessary dependencies.")
-
-
 cli.add_command(create_cell)
 cli.add_command(connect_cell)
 cli.add_command(view_cell)
@@ -849,7 +813,6 @@ cli.add_command(connect_node)
 cli.add_command(update_node)
 cli.add_command(disconnect_node)
 cli.add_command(delete_node)
-cli.add_command(call_cellai)
 
 
 if __name__ == "__main__":

{neuronum-3.0.2 → neuronum-4.0.0}/neuronum/neuronum.py

@@ -4,7 +4,6 @@ import ssl
 import websockets
 import json
 import asyncio
-from bleak import BleakScanner
 
 class Cell:
     def __init__(self, host: str, password: str, network: str, synapse: str):
@@ -410,7 +409,6 @@ class Cell:
             await writer.wait_closed()
 
 
-
     async def sync(self, stx: Optional[str] = None) -> AsyncGenerator[str, None]:
         full_url = f"wss://{self.network}/sync/{stx}"
         
@@ -446,177 +444,4 @@ class Cell:
             print(f"An unexpected error occurred: {e}")
 
 
-    async def sign_contract(self, contractID: str):
-        full_url = f"https://{self.network}/api/sign_contract"
-
-        sign_contract_payload = {
-            "contractID": contractID,
-            "cell": self.to_dict()
-        }
-
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.post(full_url, json=sign_contract_payload) as response:
-                    response.raise_for_status()
-                    data = await response.json()
-                    return data.get("token")
-
-            except aiohttp.ClientError as e:
-                print(f"Error sending request: {e}")
-            except Exception as e:
-                print(f"Unexpected error: {e}")
-
-
-    async def validate_token(self, token: str, cp: str, contractID: str):
-        full_url = f"https://{self.network}/api/validate_token"
-
-        validate_payload = {
-            "token": token,
-            "cp": cp,
-            "contractID": contractID,
-            "cell": self.to_dict()
-        }
-
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.post(full_url, json=validate_payload) as response:
-                    response.raise_for_status()
-                    data = await response.json()
-                    return data.get("validity")
-
-            except aiohttp.ClientError as e:
-                print(f"Error sending request: {e}")
-            except Exception as e:
-                print(f"Unexpected error: {e}")
-
-
-    async def request_token(self, cp: str, contractID: str):
-        full_url = f"https://{self.network}/api/request_token"
-
-        request_token_payload = {
-            "cp": cp,
-            "contractID": contractID,
-            "cell": self.to_dict()
-        }
-
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.post(full_url, json=request_token_payload) as response:
-                    response.raise_for_status()
-                    data = await response.json()
-                    print(f"Response from Neuronum: {data}")
-                    return data
-
-            except aiohttp.ClientError as e:
-                print(f"Error sending request: {e}")
-            except Exception as e:
-                print(f"Unexpected error: {e}")
-
-    
-    async def present_token(self, token: str, cp: str, contractID: str):
-        full_url = f"https://{self.network}/api/present_token"
-
-        present_token_payload = {
-            "token": token,
-            "cp": cp,
-            "contractID": contractID,
-            "cell": self.to_dict()
-        }
-
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.post(full_url, json=present_token_payload) as response:
-                    response.raise_for_status()
-                    data = await response.json()
-                    print(f"Response from Neuronum: {data}")
-                    return data
-
-            except aiohttp.ClientError as e:
-                print(f"Error sending request: {e}")
-            except Exception as e:
-                print(f"Unexpected error: {e}")
-
-
-    async def create_contract(self, descr: str, details: dict, partners: list):
-        full_url = f"https://{self.network}/api/create_contract"
-
-        create_contract_payload = {
-            "cell": self.to_dict(),
-            "descr": descr,
-            "details": details,
-            "partners": partners
-        }
-
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.post(full_url, json=create_contract_payload) as response:
-                    response.raise_for_status()
-                    data = await response.json()
-                    return data.get("contractID")
-
-            except aiohttp.ClientError as e:
-                print(f"Error sending request: {e}")
-            except Exception as e:
-                print(f"Unexpected error: {e}")
-
-
-    async def delete_contract(self, contractID: str):
-        full_url = f"https://{self.network}/api/delete_contract"
-
-        request_payload = {
-            "cell": self.to_dict(),
-            "contractID": contractID
-        }
-
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.post(full_url, json=request_payload) as response:
-                    response.raise_for_status()
-                    data = await response.json()
-                    print(f"Response from Neuronum: {data}")
-                    return data
-
-            except aiohttp.ClientError as e:
-                print(f"Error sending request: {e}")
-            except Exception as e:
-                print(f"Unexpected error: {e}")
-
-
-    async def list_contracts(self):
-        full_url = f"https://{self.network}/api/list_contracts"
-
-        list_contracts_payload = {
-            "cell": self.to_dict()
-        }
-
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.get(full_url, json=list_contracts_payload) as response:
-                    response.raise_for_status()
-                    data = await response.json()
-                    return data.get("Contracts", [])
-
-            except aiohttp.ClientError as e:
-                print(f"Error sending request: {e}")
-            except Exception as e:
-                print(f"Unexpected error: {e}")
-
-        
-    def device_found(self, device, advertisement_data):
-        if device.name and (device.name.endswith("::cell") or device.name.endswith("::node")):
-            asyncio.create_task(self.queue.put(f"{device.name} - {device.address}"))
-
-    async def scan(self):
-        print("Scanning for Neuronum Cells & Nodes")
-
-        scanner = BleakScanner(self.device_found)
-        await scanner.start()
-
-        try:
-            while True:
-                yield await self.queue.get()
-        except asyncio.CancelledError:
-            await scanner.stop()
-
-
 __all__ = ['Cell']

neuronum-4.0.0/neuronum.egg-info/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: neuronum
+Version: 4.0.0
+Summary: Official client library to interact with the Neuronum Network
+Home-page: https://neuronum.net
+Author: Neuronum Cybernetics
+Author-email: welcome@neuronum.net
+Project-URL: GitHub, https://github.com/neuronumcybernetics/neuronum
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: websockets
+Requires-Dist: click
+Requires-Dist: questionary
+Requires-Dist: python-dotenv
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+![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)
+
+
+### **Getting Started Goals**
+- Learn about Neuronum
+- Connect to Neuronum
+- Build on Neuronum
+
+
+### **About Neuronum**
+Neuronum is a central serverless data gateway automating the processing and distribution of data transmission, storage, and streaming.
+In practice, Neuronum forms an interconnected network of soft- and hardware components (Nodes) exchanging data in real time.
+
+
+### **Network Attributes**
+**Cell & Nodes**
+- Cell: Account to connect and interact with the Neuronum Network
+- Nodes: Software and Hardware components connected to Neuronum
+
+**Data Gateways**
+- Transmitters (TX): Automate data transfer in standardized formats
+- Circuits (CTX): Store data in cloud-based key-value-label databases
+- Streams (STX): Stream, synchronize, and control data in real time
+
+
+#### Requirements
+- Python >= 3.8 -> https://www.python.org/downloads/
+- neuronum >= 4.0.0 -> https://pypi.org/project/neuronum/
+
+
+------------------
+
+
+### **Connect to Neuronum**
+Installation
+```sh
+pip install neuronum                    # install neuronum dependencies
+```
+
+Create Cell:
+```sh
+neuronum create-cell                    # create Cell / Cell type / Cell network 
+```
+
+Connect Cell:
+```sh
+neuronum connect-cell                   # connect Cell
+```
+
+View connected Cell:
+```sh
+neuronum view-cell                      # view Cell / output = Connected Cell: 'your_cell'"
+```
+
+Disconnect Cell:
+```sh
+neuronum disconnect-cell                # disconnect Cell
+```
+
+Delete Cell:
+```sh
+neuronum delete-cell                    # delete Cell
+```
+
+
+------------------
+
+
+
+### **Build on Neuronum**
+Initialize Node (default template):
+```sh
+neuronum init-node                      # initialize a Node with default template
+```
+
+Initialize Node (stream template):
+```sh
+neuronum init-node --stream id::stx     # initialize a Node with stream template
+```
+
+Initialize Node (sync template):
+```sh
+neuronum init-node --sync id::stx       # initialize a Node with sync template
+```
+
+cd to Node folder:
+```sh
+cd node_node_id                         # change to Node folder
+```
+
+Start Node:
+```sh
+neuronum start-node                     # start Node
+```
+
+Start Node (detached mode):
+```sh
+neuronum start-node --d                 # start Node in "detached" mode
+```
+
+Stop Node:
+```sh
+neuronum stop-node                      # stop Node
+```
+
+Connect Node:
+```sh
+neuronum connect-node                   # connect your Node / Node type / Node description
+```
+
+Update Node:
+```sh
+neuronum update-node                    # update your Node
+```
+
+Disconnect Node:
+```sh
+neuronum disconnect-node                # disconnect your Node
+```
+
+Delete Node:
+```sh
+neuronum delete-node                    # delete your Node
+```

{neuronum-3.0.2 → neuronum-4.0.0}/neuronum.egg-info/SOURCES.txt

@@ -1,8 +1,6 @@
 LICENSE
 README.md
 setup.py
-cellai/__init__.py
-cellai/cellai.py
 cli/__init__.py
 cli/main.py
 neuronum/__init__.py

{neuronum-3.0.2 → neuronum-4.0.0}/neuronum.egg-info/requires.txt

@@ -3,5 +3,4 @@ websockets
 click
 questionary
 python-dotenv
-bleak
 requests

{neuronum-3.0.2 → neuronum-4.0.0}/neuronum.egg-info/top_level.txt

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

{neuronum-3.0.2 → neuronum-4.0.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='neuronum',
-    version='3.0.2',
+    version='4.0.0',
     author='Neuronum Cybernetics',
     author_email='welcome@neuronum.net',
     description='Official client library to interact with the Neuronum Network',
@@ -12,7 +12,7 @@ setup(
     project_urls={
         "GitHub": "https://github.com/neuronumcybernetics/neuronum",
     },
-    packages=find_packages(include=["neuronum", "cellai", "cli"]),
+    packages=find_packages(include=["neuronum", "cli"]),
     classifiers=[
         "Programming Language :: Python :: 3",
         "License :: OSI Approved :: MIT License",
@@ -25,7 +25,6 @@ setup(
         'click',
         'questionary',
         'python-dotenv',
-        'bleak',
         'requests',
     ],
     entry_points={

neuronum-3.0.2/PKG-INFO

@@ -1,125 +0,0 @@
-Metadata-Version: 2.4
-Name: neuronum
-Version: 3.0.2
-Summary: Official client library to interact with the Neuronum Network
-Home-page: https://neuronum.net
-Author: Neuronum Cybernetics
-Author-email: welcome@neuronum.net
-Project-URL: GitHub, https://github.com/neuronumcybernetics/neuronum
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aiohttp
-Requires-Dist: websockets
-Requires-Dist: click
-Requires-Dist: questionary
-Requires-Dist: python-dotenv
-Requires-Dist: bleak
-Requires-Dist: requests
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-![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)
-
-A Getting Started into the Neuronum Network: Build, deploy and automate serverless data infrastructures for an interconnected world
-
-### **What's New in neuronum 3.0.2**
-- Added CLI feature in `neuronum connect-node`: Select whether your Node will be publicly or privately listed
-
-### **New Feature Set**
-- **Cell/Cell-CLI**: Create and manage your Neuronum Cell, a unique identity for interacting with the Network, directly from the command line.
-- **Nodes/Node-CLI**: Setup and manage Neuronum Nodes, the software and hardware components that power the Network, via the command line.
-- **Transmitters (TX)**: Automate economic data transfer using predefined templates for standardized data exchange.
-- **Circuits (CTX)**: Store, manage, and retrieve structured data with Circuits, a cloud-based Key-Value-Label database.
-- **Streams (STX)**: Stream, synchronize, and control data in real time, enabling dynamic and responsive data flows.
-- **Contracts/Tokens**: Automate service exchange and authorization, ensuring secure interactions between Cells and Nodes.
-- **Scan**: Discover Cells and Nodes via BLE-based scanning, powered by Bleak, for seamless network integration.
-- **Cellai**: A local AI assistant currently in development (version 0.0.1). While still evolving, Cellai is designed to automate communication between Cells and Nodes, optimizing intelligent data flow and network interactions in future releases.
-
-
-## Getting Started Goals
-- **Neuronum Cell**: Create a Cell to start interacting with the Network
-- **Neuronum Node**: Setup a Node that streams and syncs the message: Hello, Neuronum! in real-time
-
-
-### Requirements
-- Python >= 3.8 -> https://www.python.org/downloads/
-- neuronum >= 3.0.0 -> https://pypi.org/project/neuronum/
-
-
-### Installation
-Install the Neuronum library:
-```sh
-$ pip install neuronum         # install the neuronum dependencies
-```
-
-### Neuronum Cell
-Create your Cell:
-```sh
-$ neuronum create-cell         # create Cell / select network and type
-```
-
-Connect your Cell:
-```sh
-$ neuronum connect-cell        # connect Cell
-```
-
-View connected Cell:
-```sh
-$ neuronum view-cell           # view Cell ID / output = Connected Cell: 'your_cell_id'"
-```
-
-### Neuronum Node
-Initialize your Node:
-```sh
-$ neuronum init-node           # initialize a Node with default template
-```
-
-cd into Node Folder:
-```sh
-$ cd node_nodeID               # change directory
-```
-
-Start your Node:
-```sh
-$ neuronum start-node          # start Node / scan = Off / output = "Hello, Neuronum!"
-```
-
-Stop your Node:
-```sh
-$ neuronum stop-node           # stop Node
-```
-
-Connect your Node:
-```sh
-$ neuronum connect-node        # connect your Node / Node description = Test Node
-```
-
-Update your Node:
-```sh
-$ neuronum update-node         # update your Node
-```
-
-Disconnect your Node:
-```sh
-$ neuronum disconnect-node     # disconnect your Node
-```
-
-Delete your Node:
-```sh
-$ neuronum delete-node         # delete your Node
-```

neuronum-3.0.2/README.md

@@ -1,92 +0,0 @@
-![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)
-
-A Getting Started into the Neuronum Network: Build, deploy and automate serverless data infrastructures for an interconnected world
-
-### **What's New in neuronum 3.0.2**
-- Added CLI feature in `neuronum connect-node`: Select whether your Node will be publicly or privately listed
-
-### **New Feature Set**
-- **Cell/Cell-CLI**: Create and manage your Neuronum Cell, a unique identity for interacting with the Network, directly from the command line.
-- **Nodes/Node-CLI**: Setup and manage Neuronum Nodes, the software and hardware components that power the Network, via the command line.
-- **Transmitters (TX)**: Automate economic data transfer using predefined templates for standardized data exchange.
-- **Circuits (CTX)**: Store, manage, and retrieve structured data with Circuits, a cloud-based Key-Value-Label database.
-- **Streams (STX)**: Stream, synchronize, and control data in real time, enabling dynamic and responsive data flows.
-- **Contracts/Tokens**: Automate service exchange and authorization, ensuring secure interactions between Cells and Nodes.
-- **Scan**: Discover Cells and Nodes via BLE-based scanning, powered by Bleak, for seamless network integration.
-- **Cellai**: A local AI assistant currently in development (version 0.0.1). While still evolving, Cellai is designed to automate communication between Cells and Nodes, optimizing intelligent data flow and network interactions in future releases.
-
-
-## Getting Started Goals
-- **Neuronum Cell**: Create a Cell to start interacting with the Network
-- **Neuronum Node**: Setup a Node that streams and syncs the message: Hello, Neuronum! in real-time
-
-
-### Requirements
-- Python >= 3.8 -> https://www.python.org/downloads/
-- neuronum >= 3.0.0 -> https://pypi.org/project/neuronum/
-
-
-### Installation
-Install the Neuronum library:
-```sh
-$ pip install neuronum         # install the neuronum dependencies
-```
-
-### Neuronum Cell
-Create your Cell:
-```sh
-$ neuronum create-cell         # create Cell / select network and type
-```
-
-Connect your Cell:
-```sh
-$ neuronum connect-cell        # connect Cell
-```
-
-View connected Cell:
-```sh
-$ neuronum view-cell           # view Cell ID / output = Connected Cell: 'your_cell_id'"
-```
-
-### Neuronum Node
-Initialize your Node:
-```sh
-$ neuronum init-node           # initialize a Node with default template
-```
-
-cd into Node Folder:
-```sh
-$ cd node_nodeID               # change directory
-```
-
-Start your Node:
-```sh
-$ neuronum start-node          # start Node / scan = Off / output = "Hello, Neuronum!"
-```
-
-Stop your Node:
-```sh
-$ neuronum stop-node           # stop Node
-```
-
-Connect your Node:
-```sh
-$ neuronum connect-node        # connect your Node / Node description = Test Node
-```
-
-Update your Node:
-```sh
-$ neuronum update-node         # update your Node
-```
-
-Disconnect your Node:
-```sh
-$ neuronum disconnect-node     # disconnect your Node
-```
-
-Delete your Node:
-```sh
-$ neuronum delete-node         # delete your Node
-```

neuronum-3.0.2/cellai/cellai.py

@@ -1,7 +0,0 @@
-def main():
-    print("Hello, it's your task assistant Cellai")
-    print("I'm still in development, but my creators are happy to share updates.")
-    print("Feel free to reach out to them at <welcome@neuronum.net> for more details.")
-
-if __name__ == "__main__":
-    main()

neuronum-3.0.2/neuronum.egg-info/PKG-INFO

@@ -1,125 +0,0 @@
-Metadata-Version: 2.4
-Name: neuronum
-Version: 3.0.2
-Summary: Official client library to interact with the Neuronum Network
-Home-page: https://neuronum.net
-Author: Neuronum Cybernetics
-Author-email: welcome@neuronum.net
-Project-URL: GitHub, https://github.com/neuronumcybernetics/neuronum
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aiohttp
-Requires-Dist: websockets
-Requires-Dist: click
-Requires-Dist: questionary
-Requires-Dist: python-dotenv
-Requires-Dist: bleak
-Requires-Dist: requests
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-![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)
-
-A Getting Started into the Neuronum Network: Build, deploy and automate serverless data infrastructures for an interconnected world
-
-### **What's New in neuronum 3.0.2**
-- Added CLI feature in `neuronum connect-node`: Select whether your Node will be publicly or privately listed
-
-### **New Feature Set**
-- **Cell/Cell-CLI**: Create and manage your Neuronum Cell, a unique identity for interacting with the Network, directly from the command line.
-- **Nodes/Node-CLI**: Setup and manage Neuronum Nodes, the software and hardware components that power the Network, via the command line.
-- **Transmitters (TX)**: Automate economic data transfer using predefined templates for standardized data exchange.
-- **Circuits (CTX)**: Store, manage, and retrieve structured data with Circuits, a cloud-based Key-Value-Label database.
-- **Streams (STX)**: Stream, synchronize, and control data in real time, enabling dynamic and responsive data flows.
-- **Contracts/Tokens**: Automate service exchange and authorization, ensuring secure interactions between Cells and Nodes.
-- **Scan**: Discover Cells and Nodes via BLE-based scanning, powered by Bleak, for seamless network integration.
-- **Cellai**: A local AI assistant currently in development (version 0.0.1). While still evolving, Cellai is designed to automate communication between Cells and Nodes, optimizing intelligent data flow and network interactions in future releases.
-
-
-## Getting Started Goals
-- **Neuronum Cell**: Create a Cell to start interacting with the Network
-- **Neuronum Node**: Setup a Node that streams and syncs the message: Hello, Neuronum! in real-time
-
-
-### Requirements
-- Python >= 3.8 -> https://www.python.org/downloads/
-- neuronum >= 3.0.0 -> https://pypi.org/project/neuronum/
-
-
-### Installation
-Install the Neuronum library:
-```sh
-$ pip install neuronum         # install the neuronum dependencies
-```
-
-### Neuronum Cell
-Create your Cell:
-```sh
-$ neuronum create-cell         # create Cell / select network and type
-```
-
-Connect your Cell:
-```sh
-$ neuronum connect-cell        # connect Cell
-```
-
-View connected Cell:
-```sh
-$ neuronum view-cell           # view Cell ID / output = Connected Cell: 'your_cell_id'"
-```
-
-### Neuronum Node
-Initialize your Node:
-```sh
-$ neuronum init-node           # initialize a Node with default template
-```
-
-cd into Node Folder:
-```sh
-$ cd node_nodeID               # change directory
-```
-
-Start your Node:
-```sh
-$ neuronum start-node          # start Node / scan = Off / output = "Hello, Neuronum!"
-```
-
-Stop your Node:
-```sh
-$ neuronum stop-node           # stop Node
-```
-
-Connect your Node:
-```sh
-$ neuronum connect-node        # connect your Node / Node description = Test Node
-```
-
-Update your Node:
-```sh
-$ neuronum update-node         # update your Node
-```
-
-Disconnect your Node:
-```sh
-$ neuronum disconnect-node     # disconnect your Node
-```
-
-Delete your Node:
-```sh
-$ neuronum delete-node         # delete your Node
-```