neuronum 4.0.0__py3-none-any.whl → 5.0.0__py3-none-any.whl

cli/main.py

@@ -440,8 +440,7 @@ cell = neuronum.Cell(
 )
 
 async def main():
-    STX = "{stx}"
-    async for operation in cell.sync(STX):
+    async for operation in cell.sync():
         message = operation.get("data").get("message")
         print(message)
 
@@ -469,14 +468,13 @@ cell = neuronum.Cell(
 )
 
 async def main():
-    STX = "{stx}"
     label = "Welcome to Neuronum"
     
     while True:
         data = {{
             "message": "Hello, Neuronum!"
         }}
-        await cell.stream(label, data, STX)
+        await cell.stream(label, data)
 
 asyncio.run(main())
 """)

neuronum/neuronum.py

@@ -13,6 +13,7 @@ class Cell:
         self.synapse = synapse
         self.queue = asyncio.Queue()
 
+
     def to_dict(self) -> dict:
         return {
             "host": self.host,
@@ -20,8 +21,98 @@ class Cell:
             "synapse": self.synapse
         }
 
+
     def __repr__(self) -> str:
         return f"Cell(host={self.host}, password={self.password}, network={self.network}, synapse={self.synapse})"
+    
+
+    async def stream(self, label: str, data: dict, stx: Optional[str] = None, retry_delay: int = 3):
+        context = ssl.create_default_context()
+        context.check_hostname = True
+        context.verify_mode = ssl.CERT_REQUIRED
+
+        while True:
+            try:
+                reader, writer = await asyncio.open_connection(self.network, 55555, ssl=context, server_hostname=self.network)
+
+                credentials = f"{self.host}\n{self.password}\n{self.synapse}\n{stx}\n"
+                writer.write(credentials.encode("utf-8"))
+                await writer.drain()
+
+                response = await reader.read(1024)
+                response_text = response.decode("utf-8").strip()
+
+                if "Authentication successful" not in response_text:
+                    print("Authentication failed, retrying...")
+                    writer.close()
+                    await writer.wait_closed()
+                    await asyncio.sleep(retry_delay)
+                    continue
+
+                stream_payload = {
+                    "label": label,
+                    "data": data,
+                }
+
+                writer.write(json.dumps(stream_payload).encode("utf-8"))
+                await writer.drain()
+
+                response = await reader.read(1024)
+                response_text = response.decode("utf-8").strip()
+
+                if response_text == "Sent":
+                    print(f"Success: {response_text} - {stream_payload}")
+                    break
+                else:
+                    print(f"Error sending: {stream_payload}")
+
+            except (ssl.SSLError, ConnectionError) as e:
+                print(f"Connection error: {e}, retrying...")
+                await asyncio.sleep(retry_delay)
+
+            except Exception as e:
+                print(f"Unexpected error: {e}, retrying...")
+                await asyncio.sleep(retry_delay)
+
+            finally:
+                if 'writer' in locals():
+                    writer.close()
+                    await writer.wait_closed()
+
+
+    async def sync(self, stx: Optional[str] = None) -> AsyncGenerator[str, None]:
+        full_url = f"wss://{self.network}/sync/{stx}"
+        
+        auth_payload = {
+            "host": self.host,
+            "password": self.password,
+            "synapse": self.synapse,
+        }
+
+        try:
+            async with websockets.connect(full_url) as ws:
+                await ws.send(json.dumps(auth_payload))
+                print("Listening to Stream...")
+
+                try:
+                    while True:
+                        try:
+                            raw_operation = await ws.recv()
+                            operation = json.loads(raw_operation)
+                            yield operation
+
+                        except asyncio.TimeoutError:
+                            print("No initial data received. Continuing to listen...")
+                            continue
+
+                except asyncio.CancelledError:
+                    print("Connection closed.")
+
+        except websockets.exceptions.WebSocketException as e:
+            print(f"WebSocket error occurred: {e}")
+
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}")
            
 
     async def create_tx(self, descr: str, key_values: dict, stx: str, label: str, partners: list):
@@ -85,7 +176,17 @@ class Cell:
                     response.raise_for_status()
                     response.raise_for_status()
                     data = await response.json()
-                    print(data["message"])
+                    if data["success"] == "activated":
+                        async for operation in self.sync():
+                            label = operation.get("label")
+                            if label == "tx_response":      
+                                operation_id = operation.get("operationID")
+                                if operation_id == data["operationID"]:                                
+                                    tx_response = operation.get("data")
+                                    return tx_response
+                                
+                    else:
+                        print(data["success"], data["message"])
 
             except aiohttp.ClientError as e:
                 print(f"Error sending request: {e}")
@@ -93,6 +194,31 @@ class Cell:
                 print(f"Unexpected error: {e}")
 
 
+    async def tx_response(self, txID: str, cc: str, operationID: str, data: dict):
+        url = f"https://{self.network}/api/tx_response/{txID}"
+
+        tx_response = {
+            "cc": cc,
+            "operationID": operationID,
+            "data": data,
+            "cell": self.to_dict()
+        }
+
+        async with aiohttp.ClientSession() as session:
+            for attempt in range(5):
+                try:
+                    async with session.post(url, json=tx_response) as response:
+                        response.raise_for_status()
+                        data = await response.json()
+                
+                except aiohttp.ClientError as e:
+                    print(f"Attempt {attempt + 1}: Error sending request: {e}")
+                except Exception as e:
+                    print(f"Attempt {attempt + 1}: Unexpected error: {e}")
+            
+            print(data["message"])
+
+
     async def create_ctx(self, descr: str, partners: list):
         url = f"https://{self.network}/api/create_ctx"
 
@@ -368,80 +494,4 @@ class Cell:
                 print(f"Unexpected error: {e}")
 
 
-    async def stream(self, label: str, data: dict, stx: Optional[str] = None):
-        context = ssl.create_default_context()
-        context.check_hostname = True
-        context.verify_mode = ssl.CERT_REQUIRED
-
-        try:
-            reader, writer = await asyncio.open_connection(self.network, 55555, ssl=context, server_hostname=self.network)
-
-            credentials = f"{self.host}\n{self.password}\n{self.synapse}\n{stx}\n"
-            writer.write(credentials.encode("utf-8"))
-            await writer.drain()
-
-            response = await reader.read(1024)
-            response_text = response.decode("utf-8")
-
-            if "Authentication successful" not in response_text:
-                print("Authentication failed")
-                writer.close()
-                await writer.wait_closed()
-                return
-
-            stream_payload = {
-                "label": label,
-                "data": data,
-            }
-
-            writer.write(json.dumps(stream_payload).encode("utf-8"))
-            await writer.drain()
-            print(f"Sent: {stream_payload}")
-
-        except ssl.SSLError as e:
-            print(f"SSL error occurred: {e}")
-
-        except Exception as e:
-            print(f"An unexpected error occurred: {e}")
-
-        finally:
-            writer.close()
-            await writer.wait_closed()
-
-
-    async def sync(self, stx: Optional[str] = None) -> AsyncGenerator[str, None]:
-        full_url = f"wss://{self.network}/sync/{stx}"
-        
-        auth_payload = {
-            "host": self.host,
-            "password": self.password,
-            "synapse": self.synapse,
-        }
-
-        try:
-            async with websockets.connect(full_url) as ws:
-                await ws.send(json.dumps(auth_payload))
-                print("Listening to Stream...")
-
-                try:
-                    while True:
-                        try:
-                            raw_operation = await ws.recv()
-                            operation = json.loads(raw_operation)
-                            yield operation
-
-                        except asyncio.TimeoutError:
-                            print("No initial data received. Continuing to listen...")
-                            continue
-
-                except asyncio.CancelledError:
-                    print("Connection closed.")
-
-        except websockets.exceptions.WebSocketException as e:
-            print(f"WebSocket error occurred: {e}")
-
-        except Exception as e:
-            print(f"An unexpected error occurred: {e}")
-
-
 __all__ = ['Cell']

{neuronum-4.0.0.dist-info → neuronum-5.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuronum
-Version: 4.0.0
+Version: 5.0.0
 Summary: Official client library to interact with the Neuronum Network
 Home-page: https://neuronum.net
 Author: Neuronum Cybernetics
@@ -42,14 +42,13 @@ Dynamic: summary
 
 
 ### **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.
+Neuronum is a framework to build serverless data gateways automating the processing and distribution of data transmission, storage, and streaming.
 
 
-### **Network Attributes**
+### **Neuronum Attributes**
 **Cell & Nodes**
-- Cell: Account to connect and interact with the Neuronum Network
-- Nodes: Software and Hardware components connected to Neuronum
+- Cell: Account to connect and interact with Neuronum
+- Nodes: Soft- and Hardware components hosting data gateways
 
 **Data Gateways**
 - Transmitters (TX): Automate data transfer in standardized formats
@@ -76,83 +75,31 @@ Create Cell:
 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
+neuronum view-cell                      # view Cell / output = Connected Cell: 'cell_id'"
 ```
 
 
 ------------------
 
 
-
 ### **Build on Neuronum**
+**Node Examples:**  
+Visit: https://github.com/neuronumcybernetics/neuronum/tree/main/how_tos/nodes
+
 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-5.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/main.py,sha256=g7Y-W1G7C1firXHsEnBFyqa52nSk6GVzcax_6up0Ezg,24991
+neuronum/__init__.py,sha256=Drsm263_w3_VWgl1YsKLUr8WwVodqV3TSjqpxLjyq_M,46
+neuronum/neuronum.py,sha256=t1BDzFDzbq9kQN7RSFIagctSGWOoP5MewjpauJxhH5k,17511
+neuronum-5.0.0.dist-info/licenses/LICENSE,sha256=UiZjNHiCyRP6WoZfbYQh9cv4JW96wIofKXmzBJrYSUk,1125
+neuronum-5.0.0.dist-info/METADATA,sha256=KkMqALQtmMd_2gnstSXwjqx2AvkegZr-26c1oBXAHao,2883
+neuronum-5.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+neuronum-5.0.0.dist-info/entry_points.txt,sha256=XKYBcRNxGeJpZZkDPsa8HA_RaJ7Km_R_JaUq5T9Nk2U,42
+neuronum-5.0.0.dist-info/top_level.txt,sha256=ru8Fr84cHm6oHr_DcJ8-uaq3RTiuCRFIr6AC8V0zPu4,13
+neuronum-5.0.0.dist-info/RECORD,,

neuronum-4.0.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cli/main.py,sha256=SLkV4tmugC7UfnIJs5vUeMWf16An2NQuTnEV6PTNfWQ,25037
-neuronum/__init__.py,sha256=Drsm263_w3_VWgl1YsKLUr8WwVodqV3TSjqpxLjyq_M,46
-neuronum/neuronum.py,sha256=botQ0FJIf5e00MqfUeIcD6aAchys9vSsQ3ymj8YzGMc,15223
-neuronum-4.0.0.dist-info/licenses/LICENSE,sha256=UiZjNHiCyRP6WoZfbYQh9cv4JW96wIofKXmzBJrYSUk,1125
-neuronum-4.0.0.dist-info/METADATA,sha256=ePj9Xk9ypPSBKz7xF0KIVyBgEYVyQJ7djS3HPinScVM,4036
-neuronum-4.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-neuronum-4.0.0.dist-info/entry_points.txt,sha256=XKYBcRNxGeJpZZkDPsa8HA_RaJ7Km_R_JaUq5T9Nk2U,42
-neuronum-4.0.0.dist-info/top_level.txt,sha256=ru8Fr84cHm6oHr_DcJ8-uaq3RTiuCRFIr6AC8V0zPu4,13
-neuronum-4.0.0.dist-info/RECORD,,