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

neuronum/neuronum.py

@@ -5,7 +5,6 @@ import ssl
 from websocket import create_connection
 import json
 
-
 class Cell:
     def __init__(self, host: str, password: str, network: str, synapse: str):
         self.host = host
@@ -30,12 +29,63 @@ class Cell:
         self.sock.sendall(credentials.encode('utf-8'))
 
         response = self.sock.recv(1024).decode('utf-8')
-        print(response)
         return "Authentication successful" in response
     
 
-    def activate(self, txID: str, data: dict):
-        url = f"https://{self.network}/activateTX/{txID}"
+    def create_tx(self, descr: str, key_values: dict, ctx: str, label: str, partners: list):
+        url = f"https://{self.network}/api/create_tx"
+
+        TX = {
+            "descr": descr,
+            "key_values": key_values,
+            "ctx": ctx,
+            "label": label,
+            "partners": partners,
+            "cell": self.to_dict()
+        }
+
+        try:
+            response = requests.post(
+                url,
+                json=TX,
+            )
+
+            response.raise_for_status()
+
+            return response.json()["txID"]
+
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def delete_tx(self, txID: str):
+        url = f"https://{self.network}/api/delete_tx"
+
+        TX = {
+            "txID": txID,
+            "cell": self.to_dict()
+        }
+
+        try:
+            response = requests.post(
+                url,
+                json=TX,
+            )
+
+            response.raise_for_status()
+
+            print(f"Response from Neuronum: {response.json()}")
+
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+    
+
+    def activate_tx(self, txID: str, data: dict):
+        url = f"https://{self.network}/api/activate_tx/{txID}"
 
         TX = {
             "data": data,
@@ -58,17 +108,114 @@ class Cell:
             print(f"Unexpected error: {e}")
 
 
+    def create_ctx(self, descr: str, partners: list):
+        url = f"https://{self.network}/api/create_ctx"
+
+        CTX = {
+            "descr": descr,
+            "partners": partners,
+            "cell": self.to_dict()
+        }
+
+        try:
+            response = requests.post(
+                url,
+                json=CTX,
+            )
+
+            response.raise_for_status()
+
+            return response.json()["ctxID"]
+
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def delete_ctx(self, ctxID: str):
+        url = f"https://{self.network}/api/delete_ctx"
+
+        CTX = {
+            "ctxID": ctxID,
+            "cell": self.to_dict()
+        }
+
+        try:
+            response = requests.post(
+                url,
+                json=CTX,
+            )
+
+            response.raise_for_status()
+
+            print(f"Response from Neuronum: {response.json()}")
+
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def create_stx(self, descr: str, partners: list):
+        url = f"https://{self.network}/api/create_stx"
+
+        STX = {
+            "descr": descr,
+            "partners": partners,
+            "cell": self.to_dict()
+        }
+
+        try:
+            response = requests.post(
+                url,
+                json=STX,
+            )
+
+            response.raise_for_status()["stxID"]
+
+            return response.json()
+
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def delete_stx(self, stxID: str):
+        url = f"https://{self.network}/api/delete_stx"
+
+        STX = {
+            "stxID": stxID,
+            "cell": self.to_dict()
+        }
+
+        try:
+            response = requests.post(
+                url,
+                json=STX,
+            )
+
+            response.raise_for_status()
+
+            print(f"Response from Neuronum: {response.json()}")
+
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
 
-    def register(self, node: str, mode: str, stx: str):
+    def register_node(self, descr: str, mode: str, stx: str):
         if mode == "public":
-            url = f"https://{self.network}/register/node/public"
+            url = f"https://{self.network}/api/register_node/public"
         elif mode == "private":
-            url = f"https://{self.network}/register/node/private"
+            url = f"https://{self.network}/api/register_node/private"
         else:
             return {"error": "Invalid mode", "message": "Mode has to be 'public' or 'private'"}
 
         node_data = {
-            "name": node,
+            "descr": descr,
             "mode": mode,
             "stream": stx,
             "cell": self.to_dict()
@@ -82,7 +229,7 @@ class Cell:
 
             response.raise_for_status()
 
-            print(f"Response from Neuronum: {response.json()}")
+            return response.json()["nodeID"]
 
         except requests.exceptions.RequestException as e:
             print(f"Error sending request: {e}")
@@ -90,9 +237,85 @@ class Cell:
             print(f"Unexpected error: {e}")
 
 
+    def delete_node(self, nodeID: str):
+        url = f"https://{self.network}/api/delete_node"
+
+        delete_node = {
+            "nodeID": nodeID,
+            "cell": self.to_dict()
+        }
 
-    def test_connection(self):
-            url = f"https://{self.network}/testConnection"
+        try:
+            response = requests.post(
+                url,
+                json=delete_node,
+            )
+
+            response.raise_for_status()
+            print(response.json())
+
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def list_tx(self, cellID: str):
+        full_url = f"https://{self.network}/api/list_tx"
+        
+        list_tx = {
+            "cell": self.to_dict(),  
+            "cellID": cellID
+        }
+
+        try:
+            response = requests.post(full_url, json=list_tx)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def list_ctx(self, cellID: str):
+        full_url = f"https://{self.network}/api/list_ctx"
+        
+        list_ctx = {
+            "cell": self.to_dict(),  
+            "cellID": cellID
+        }
+
+        try:
+            response = requests.post(full_url, json=list_ctx)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def list_stx(self, cellID: str):
+        full_url = f"https://{self.network}/api/list_stx"
+        
+        list_stx = {
+            "cell": self.to_dict(),  
+            "cellID": cellID
+        }
+
+        try:
+            response = requests.post(full_url, json=list_stx)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            print(f"Error sending request: {e}")
+        except Exception as e:
+            print(f"Unexpected error: {e}")
+
+
+    def connect(self):
+            url = f"https://{self.network}/api/connect"
 
             test = {
                 "cell": self.to_dict() 
@@ -101,7 +324,7 @@ class Cell:
             try:
                 response = requests.post(url, json=test)
                 response.raise_for_status()
-                print(response.json())
+                print(response.json()["connection"]) 
             except requests.exceptions.RequestException as e:
                 print(f"Error sending request: {e}")
             except Exception as e:
@@ -110,9 +333,9 @@ class Cell:
         
     def store(self, label: str, data: dict, ctx: Optional[str] = None):
         if ctx:
-            full_url = f"https://{self.network}/store_ctx/{ctx}"
+            full_url = f"https://{self.network}/api/store_in_ctx/{ctx}"
         else:
-            full_url = f"https://{self.network}/store"
+            full_url = f"https://{self.network}/api/store"
         
         store = {
             "label": label,
@@ -130,14 +353,11 @@ class Cell:
             print(f"Unexpected error: {e}")
 
 
-
     def load(self, label: str, ctx: Optional[str] = None):
         if ctx:
-            full_url = f"https://{self.network}/load_ctx/{ctx}"
+            full_url = f"https://{self.network}/api/load_from_ctx/{ctx}"
         else:
-            full_url = f"https://{self.network}/load"
-        
-        print(f"Full URL: {full_url}")
+            full_url = f"https://{self.network}/api/load"
 
         load = {
             "label": label,
@@ -154,14 +374,11 @@ class Cell:
             print(f"Unexpected error: {e}")
 
 
-
     def delete(self, label: str, ctx: Optional[str] = None):
         if ctx:
-            full_url = f"https://{self.network}/delete_ctx/{ctx}"
+            full_url = f"https://{self.network}/api/delete_from_ctx/{ctx}"
         else:
-            full_url = f"https://{self.network}/delete"
-        
-        print(f"Full URL: {full_url}")
+            full_url = f"https://{self.network}/api/delete"
 
         delete = {
             "label": label,
@@ -180,11 +397,9 @@ class Cell:
 
     def clear(self, ctx: Optional[str] = None):
         if ctx:
-            full_url = f"https://{self.network}/clear_ctx/{ctx}"
+            full_url = f"https://{self.network}/api/clear_ctx/{ctx}"
         else:
-            full_url = f"https://{self.network}/clear"
-        
-        print(f"Full URL: {full_url}")
+            full_url = f"https://{self.network}/api/clear"
 
         clear = {
             "cell": self.to_dict() 
@@ -240,48 +455,35 @@ class Cell:
             "password": self.password,
             "synapse": self.synapse,
         }
-        ws = None
 
         try:
-            while True:
-                try:
-                    ws = create_connection(f"wss://{self.network}/sync/{stx}")
-                    ws.settimeout(1)
-                    ws.send(json.dumps(auth))
-                    print("Stream connection set...")
+            ws = create_connection(f"wss://{self.network}/sync/{stx}")
+            ws.send(json.dumps(auth))
+            print("Stream connection set...")
 
+            try:
+                while True:
                     try:
                         raw_operation = ws.recv()
                         operation = json.loads(raw_operation)
                         print("Listening to Stream...")
                         yield operation
 
-                        ws.settimeout(None)
-
-                        while True:
-                            raw_operation = ws.recv()
-                            operation = json.loads(raw_operation)
-                            yield operation
                     except socket.timeout:
-                        print("No initial data received. Retrying connection...")
-                        ws.close()
-
-                except KeyboardInterrupt:
-                    print("Stream-Synchronization ended!")
-                    if ws:
-                        ws.close()
-                    print("Connection closed. Exiting.")
-                    return
-                except Exception as e:
-                    print(f"{e}")
-                finally:
-                    if ws:
-                        ws.close()
-                        print("Connection closed.")
+                        print("No initial data received. Continuing to listen...") 
+                        continue 
+
+            except KeyboardInterrupt:
+                print("Stream-Synchronization ended!")
+            except Exception as e:
+                print(f"Error: {e}")
+            finally:
+                ws.close()
+                print("Connection closed.")
+
         except KeyboardInterrupt:
             print("Stream-Synchronization ended!")
-            if ws:
-                ws.close()
+            ws.close()
             print("Connection closed. Goodbye!")
 
 

neuronum-1.5.0.dist-info/METADATA

@@ -0,0 +1,266 @@
+Metadata-Version: 2.1
+Name: neuronum
+Version: 1.5.0
+Summary: Interact with the Neuronum Network to build & automate interconnected networks of soft- and hardware components
+Home-page: https://neuronum.net
+Author: Neuronum Cybernetics
+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.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: websocket-client
+Requires-Dist: iota-sdk
+
+![Neuronum Logo](https://neuronum.net/static/logo_pip.png "Neuronum")
+
+[![Website](https://img.shields.io/badge/Website-Neuronum-blue)](https://neuronum.net)
+[![Documentation](https://img.shields.io/badge/Docs-Read%20now-green)](https://github.com/neuronumcybernetics/neuronum)
+[![Tutorials](https://img.shields.io/badge/Tutorials-Watch%20now-red)](https://www.youtube.com/@neuronumnet)
+
+`Neuronum` is a cybernetic framework enabling businesses to build & automate interconnected networks of soft- and hardware components
+
+## Features
+- **Cell**: Identity to connect and interact with the Neuronum Network
+- **Transmitters (TX)**: Automate economic data transfer and storage
+- **Circuits (CTX)**: Store data in a Key-Value-Label database
+- **Streams (STX)**: Stream, synchronize and control data in real time
+- **Nodes**: Soft-/Hardware components participating in the Network ecosystem
+
+To interact with the Network you will need to create a Neuronum Cell. 
+Create your Cell: [Create Cell](https://neuronum.net/createcell)
+
+Start with installing the Neuronum library using pip:
+```python
+pip install neuronum
+```
+
+Configure and test Cell connection:
+```python
+import neuronum
+
+cell = neuronum.Cell(
+host="host::cell",                                                      # cell host 
+password="your_password",                                               # cell password 
+network="neuronum.net",                                                 # cell network 
+synapse="your_synapse"                                                  # cell synapse
+)           
+cell.connect()                                                          # connect to network
+```
+
+### Transmitters (TX)
+Transmitters (TX) are used to create predefined templates to receive and send data in a standardized format. Data sent with TX is always and automatically stored in a predefined Circuit (CTX)
+
+Create Transmitter (TX):
+```python
+descr = "Test Transmitter"                                              # description (max 25 characters)
+key_values = {                                                          # defined keys and example values
+    "key1": "value1",
+    "key2": "value2",
+    "key3": "value3",
+}
+ctx = "id::ctx"                                                         # select Circuit (CTX)
+label = "key1:key2"                                                     # label TX data
+partners = ["id::cell", "id::cell"]                                     # authorized Cells
+txID = cell.create_tx(descr, key_values, ctx, label, partners) 
+```
+
+Activate Transmitter (TX):
+```python
+TX = "id::tx"                                                           # select Transmitter (TX)
+data = {                                                                # enter key-values
+    "key1": "value1",
+    "key2": "value2",
+    "key3": "value3",
+}
+cell.activate_tx(TX, data)                                              # activate TX
+```
+
+Delete Transmitter (TX):
+```python
+TX = "id::tx"                                                           # select Transmitter (TX)
+cell.delete_tx(TX)                                                      # delete TX
+```
+
+List Transmitter (TX) from Cell:
+```python
+cellID = "id::cell"                                                       # select Cell
+txList = cell.list_tx(cellID)                                             # list Transmitters (TX)
+```
+
+### Circuits (CTX)
+Circuits (CTX) store and organize data sent via Transmitters (TX) using a Key-Value-Label system
+
+Create Circuit (CTX):
+```python
+descr = "Test Circuit"                                                  # description (max 25 characters) 
+partners = ["id::cell", "id::cell"]                                     # authorized Cells
+ctxID = cell.create_ctx(descr, partners)                                # create Circuit (CTX)
+```
+
+Store data on your private Circuit (CTX):
+```python
+label = "your_label"                                                    # data label (should be unique)
+data = {                                                                # data as key-value pairs
+    "key1": "value1",
+    "key2": "value2",
+    "key3": "value3",
+}
+cell.store(label, data)                                                 # store data
+```
+
+Store data on a public Circuit (CTX):
+```python
+CTX = "id::ctx"                                                         # select Circuit (CTX
+label = "your_label"                                                    # data label (should be unique)
+data = {                                                                # data as key-value pairs
+    "key1": "value1",
+    "key2": "value2",
+    "key3": "value3",
+}
+cell.store(label, data, CTX)                                            # store data
+```
+
+Load data from your private Circuit (CTX):
+```python
+label = "your_label"                                                    # select label
+data = cell.load(label)                                                 # load data by label
+key1 = data["key1"]                                                     # get data from key
+key2 = data["key2"]
+key3 = data["key3"]
+print(key1, key2, key3)                                                 # print data
+```
+
+Load data from a public Circuit (CTX):
+```python
+CTX = "id::ctx"                                                         # select Circuit (CTX)
+label = "your_label"                                                    # select label
+data = cell.load(label, CTX)                                            # load data by label
+key1 = data["key1"]                                                     # get data from key
+key2 = data["key2"]
+key3 = data["key3"]
+print(key1, key2, key3)                                                 # print data
+```
+
+Delete data from your private Circuit (CTX):
+```python
+label = "your_label"                                                    # select label
+cell.delete(label)                                                      # delete data by label
+```
+
+Delete data from a public Circuit (CTX):
+```python
+CTX = "id::ctx"                                                         # select Circuits (CTX)
+label = "your_label"                                                    # select label
+cell.delete(label, CTX)                                                 # delete data by label
+```
+
+Clear your private Circuit (CTX):
+```python
+cell.clear()                                                            # clear Circuit (CTX)
+```
+
+Clear Circuit (CTX):
+```python
+CTX = "id::ctx"                                                         # select Circuit (CTX)
+cell.clear(CTX)                                                         # clear CTX
+```
+
+Delete Circuit (CTX):
+```python
+CTX = "id::ctx"                                                         # select Circuit (CTX)
+cell.delete_ctx(CTX)                                                    # delete CTX
+```
+
+List Circuits (CTX) from Cell:
+```python
+cellID = "id::cell"                                                       # select Cell
+ctxList = cell.list_ctx(cellID)                                           # list Circuits (CTX)
+```
+
+### Streams (STX)
+Streams (STX) facilitate real-time data synchronization and interaction, ensuring real-time connectivity between Nodes in the Neuronum network
+
+Create Stream (STX):
+```python
+descr = "Test Stream"                                                   # description (max 25 characters) 
+partners = ["id::cell", "id::cell"]                                     # authorized Cells
+stxID = cell.create_stx(descr, partners)                                # create Stream (STX)
+```
+
+Stream data to your private Stream (STX):
+```python
+label = "your_label"                                                    # data label
+data = {                                                                # data as key-value pairs
+    "key1": "value1",
+    "key2": "value2",
+    "key3": "value3",
+}
+cell.stream(label, data)                                                # stream data
+```
+
+Stream data to a public Stream (STX):
+```python
+STX = "id::stx"                                                         # select Stream (STX)
+label = "your_label"                                                    # data label
+data = {                                                                # data as key-value pairs
+    "key1": "value1",
+    "key2": "value2",
+    "key3": "value3",
+}
+cell.stream(label, data, STX)                                           # stream data
+```
+
+Sync data from your private Stream (STX):
+```python
+stream = cell.sync()                                                    # synchronize Stream (STX)
+for operation in stream:                                                # load stream operations
+    label = operation.get("label")                                      # get the operation details by key
+    key1 = operation.get("data").get("key1")
+    key2 = operation.get("data").get("key2")
+    key3 = operation.get("data").get("key3")
+    ts = operation.get("time")
+    stxID = operation.get("stxID")
+    operator = operation.get("operator")
+```
+
+Sync data from a public Stream (STX):
+```python
+STX = "id::stx"                                                         # select Stream (STX)  
+stream = cell.sync(STX)                                                 # synchronize Stream (STX)
+for operation in stream:                                                # load stream operations
+    label = operation.get("label")                                      # get the operation details by key
+    key1 = operation.get("data").get("key1")
+    key2 = operation.get("data").get("key2")
+    key3 = operation.get("data").get("key3")
+    ts = operation.get("time")
+    stxID = operation.get("stxID")
+    operator = operation.get("operator")
+```
+
+List Streams (STX) from Cell:
+```python
+cellID = "id::cell"                                                       # select Cell
+stxList = cell.list_stx(cellID)                                           # list Streams (STX)
+```
+
+### Nodes
+Neuronum Nodes are computing hardware running the Neuronum Client Library, enabling seamless data transmission, synchronization, and facilitating public Stream (STX) access
+
+Register a Node with its associated Stream (STX):
+```python
+descr = "node_name"                                                     # description (max 25 characters) 
+mode = "public"                                                         # "public" or "private" Node
+STX = "id::stx"                                                         # select Stream (STX)
+nodeID = cell.register_node(descr, mode, STX)                           # register Node
+```
+
+Delete Node:
+```python
+nodeID = "id::node"                                                     # select Node
+cell.delete_node(nodeID)                                                # delete Node
+```

neuronum-1.5.0.dist-info/RECORD

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

neuronum-1.4.1.dist-info/METADATA

@@ -1,195 +0,0 @@
-Metadata-Version: 2.1
-Name: neuronum
-Version: 1.4.1
-Summary: Interact with the Neuronum Network to build, connect & automate real-time data streams
-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.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests
-Requires-Dist: websocket-client
-
-![Neuronum Logo](https://neuronum.net/static/logo_pip.png "Neuronum")
-
-[![Website](https://img.shields.io/badge/Website-Neuronum-blue)](https://neuronum.net)
-[![Documentation](https://img.shields.io/badge/Docs-Read%20now-green)](https://github.com/neuronumcybernetics/neuronum)
-[![Tutorials](https://img.shields.io/badge/Tutorials-Watch%20now-red)](https://www.youtube.com/@neuronumnet)
-
-Interact with the `Neuronum Network` to build, connect & automate real-time data streams.
-
-## Cell Features
-- **Transmitters (TX)**: Automate economic data transfer + Circuits Integration
-- **Circuits (CTX)**: A simple Key-Value-Label database to store economic data
-- **Streams (STX)**: Stream, synchronize and control data in real time
-- **Nodes**: Register hardware nodes actively streaming real-time data into the network
-
-## Getting Started
-Create your Neuronum Cell: [Create Cell](https://neuronum.net/createcell)
-
-Install the Neuronum library using pip:
-```bash
-pip install neuronum
-```
-
-Set and test Cell connection:
-```bash
-import neuronum
-
-cell = neuronum.Cell(
-host="host::cell",
-password="your_password",
-network="neuronum.net",
-synapse="your_synapse"
-)
-cell.test_connection()
-```
-
-### Transmitters (TX)
-Activate Transmitter (TX):
-```bash
-TX = "id::tx"
-data = {
-    "key1": "value1",
-    "key2": "value2",
-    "key3": "value3",
-}
-cell.activate(TX, data)
-```
-
-### Circuits (CTX)
-Store data on your private Circuit (CTX):
-```bash
-label = "your_label"
-data = {
-    "key1": "value1",
-    "key2": "value2",
-    "key3": "value3",
-}
-cell.store(label, data)
-```
-
-Store data on a public Circuit (CTX):
-```bash
-CTX = "id::ctx"
-label = "your_label"
-data = {
-    "key1": "value1",
-    "key2": "value2",
-    "key3": "value3",
-}
-cell.store(label, data, CTX)
-```
-
-Load data from your private Circuit (CTX):
-```bash
-label = "your_label"
-data = cell.load(label)
-key1 = data["key1"]
-key2 = data["key2"]
-key3 = data["key3"]
-```
-
-Load data from a public Circuit (CTX):
-```bash
-CTX = "id::ctx"
-label = "your_label"
-data = cell.load(label, CTX)
-key1 = data["key1"]
-key2 = data["key2"]
-key3 = data["key3"]
-```
-
-Delete data from your private Circuit (CTX):
-```bash
-label = "your_label"
-data = cell.delete(label)
-```
-
-Delete data from a public Circuit (CTX):
-```bash
-CTX = "id::ctx"
-label = "your_label"
-data = cell.delete(label, CTX)
-```
-
-Empty your private Circuit (CTX):
-```bash
-cell.clear()
-```
-
-Empty a public Circuit (CTX):
-```bash
-CTX = "id::ctx"
-cell.clear(CTX)
-```
-
-### Streams (STX)
-Stream data to your private Stream (STX):
-```bash
-label = "your_label"
-data = {
-    "key1": "value1",
-    "key2": "value2",
-    "key3": "value3",
-}
-cell.stream(label, data)
-```
-
-Stream data to a public Stream (STX):
-```bash
-STX = "id::stx"
-label = "your_label"
-data = {
-    "key1": "value1",
-    "key2": "value2",
-    "key3": "value3",
-}
-cell.stream(label, data, STX)
-```
-
-Sync data from your private Stream (STX):
-```bash
-stream = cell.sync()
-for operation in stream:
-    label = operation.get("label")
-    value = operation.get("data").get("key1")
-    ts = operation.get("time")
-    stxID = operation.get("stxID")
-    operator = operation.get("operator")
-```
-
-Sync data from a public Stream (STX):
-```bash
-STX = "id::stx"
-stream = cell.sync(STX)
-for operation in stream:
-    label = operation.get("label")
-    value = operation.get("data").get("key1")
-    ts = operation.get("time")
-    stxID = operation.get("stxID")
-    operator = operation.get("operator")
-```
-
-### Nodes
-Register a public Node with its associated Stream (STX):
-```bash
-node = "node_name"  # Unique node name
-mode = "public"
-STX = "id::stx"
-cell.register(node, mode, STX)
-```
-
-Register a private Node with its associated Stream (STX):
-```bash
-node = "node_name"  # Unique node name
-mode = "private"    
-STX = "id::stx"
-cell.register(node, mode, STX)
-```
-

neuronum-1.4.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-neuronum/__init__.py,sha256=Drsm263_w3_VWgl1YsKLUr8WwVodqV3TSjqpxLjyq_M,46
-neuronum/neuronum.py,sha256=X5peM3ZOK7MJU-zS8GeqBC2vBu-weAJgCfzQ48I3FvI,8908
-neuronum-1.4.1.dist-info/LICENSE,sha256=UiZjNHiCyRP6WoZfbYQh9cv4JW96wIofKXmzBJrYSUk,1125
-neuronum-1.4.1.dist-info/METADATA,sha256=lg-qZ407i0vZsj4BNVR7X8_keos82I4r7pnzMVjwjwc,4590
-neuronum-1.4.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-neuronum-1.4.1.dist-info/top_level.txt,sha256=73zXVVO9UTTiwEcSaXytsJ8n0q47OCwAqPlIh-hzWJU,9
-neuronum-1.4.1.dist-info/RECORD,,