neuronum 8.3.0__py3-none-any.whl → 9.0.0__py3-none-any.whl

cli/main.py

@@ -359,12 +359,12 @@ async def main():
         data = transmitter.get("data")
         transmitter_id = transmitter.get("transmitter_id")   
         client = transmitter.get("operator")
-        client_public_key = data.get("publicKey")  
+        client_public_key = data.get("publicKey", {{}})  
         action = data.get("action")
 
         response_data = {{}}
               
-        if action == "ping_node":
+        if action == "ping_node" or action == "start_app":
         
             html_content = template.render(client=client, ts=ts, data=action, transmitter_id=transmitter_id)
 
@@ -373,7 +373,10 @@ async def main():
                 "html": html_content
             }}
             
-            await node.tx_response(transmitter_id, response_data, client_public_key)
+            if not client_public_key:
+                await node.tx_response(transmitter_id, response_data, encrypted=False)
+            else:
+                await node.tx_response(transmitter_id, response_data, client_public_key)
 
 asyncio.run(main())
 """)
@@ -516,7 +519,6 @@ asyncio.run(main())
                 data: {{ "action": "ping_node" }},
                 nodePublicKey: '{pem_public_oneline}',
             }};
-
             if (window.parent) {{
                 window.parent.postMessage(messagePayload, '*');
             }}
@@ -536,19 +538,9 @@ f"""{{
     "version": "1.0.0",
     "author": "{host}",
     "audience": "private",
-    "logo": "https://neuronum.net/static/logo.png"
+    "logo": "https://neuronum.net/static/logo.png",
+    "node_id": "{node_id}"
   }},
-  "data_gateways": [
-    {{
-      "node_id": "{node_id}",
-      "actions": [
-        {{
-          "action": "ping_node",
-          "info": "Ping Node"
-        }}
-      ]
-    }}
-  ],
   "legals": {{
     "terms": "https://url_to_your/terms",
     "privacy_policy": "https://url_to_your/privacy_policy"
@@ -635,7 +627,7 @@ def check_node():
         with open('config.json', 'r') as f:
             data = json.load(f)
 
-        nodeID = data['data_gateways'][0]['node_id']
+        nodeID = data['app_metadata']['node_id']
 
     except FileNotFoundError:
         click.echo("Error: .env with credentials not found")
@@ -699,7 +691,7 @@ def restart_node(d):
         with open('config.json', 'r') as f:
             data = json.load(f)
 
-        nodeID = data['data_gateways'][0]['node_id']
+        nodeID = data['app_metadata']['node_id']
 
     except FileNotFoundError:
         print("Error: .env with credentials not found")
@@ -781,7 +773,7 @@ async def async_stop_node():
         with open('config.json', 'r') as f:
             data = json.load(f)
 
-        nodeID = data['data_gateways'][0]['node_id']
+        nodeID = data['app_metadata']['node_id']
 
     except FileNotFoundError:
         print("Error: .env with credentials not found")
@@ -863,7 +855,7 @@ async def async_update_node(env_data, config_data, audience: str, descr: str):
         network = env_data.get("NETWORK", "")
         synapse = env_data.get("SYNAPSE", "")
 
-        node_id = config_data.get("data_gateways", [{}])[0].get("node_id", "")
+        node_id = config_data.get("app_metadata", [{}]).get("node_id", "")
 
         with open("config.json", "r") as f:
             config_file_content = f.read()
@@ -941,7 +933,7 @@ async def _async_update_node_at_start(env_data, config_data, audience, descr):
     network = env_data.get("NETWORK", "")
     synapse = env_data.get("SYNAPSE", "")
 
-    node_id = config_data.get("data_gateways", [{}])[0].get("node_id", "")
+    node_id = config_data.get("app_metadata", [{}]).get("node_id", "")
 
     try:
         with open("config.json", "r") as f:
@@ -995,7 +987,7 @@ async def async_delete_node():
         with open('config.json', 'r') as f:
             data = json.load(f)
 
-        nodeID = data['data_gateways'][0]['node_id']
+        nodeID = data['app_metadata']['node_id']
 
     except FileNotFoundError:
         click.echo("Error: .env with credentials not found")

neuronum/neuronum.py

@@ -1,10 +1,11 @@
 import aiohttp
-from typing import AsyncGenerator
+from typing import Optional, AsyncGenerator, Union
 import websockets
 import json
 import asyncio
 import base64
 import os
+import ssl
 from pathlib import Path
 from websockets.exceptions import ConnectionClosed
 from cryptography.hazmat.primitives.asymmetric import ec
@@ -13,17 +14,17 @@ from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 from cryptography.hazmat.primitives.kdf.hkdf import HKDF
 from cryptography.hazmat.backends import default_backend
 
-
 class Node:
     def __init__(self, id: str, private_key: str, public_key: str):
         self.node_id = id
         self.private_key_path = private_key
         self.public_key_path = public_key
         self.queue = asyncio.Queue()
-        self.host = self._load_host()
-        self.network = self._load_network()
-        self.synapse = self._load_synapse()
-        self.password = self._load_password()
+        self.env = self._load_env()
+        self.host = self.env.get("HOST", "")
+        self.network = self.env.get("NETWORK", "")
+        self.synapse = self.env.get("SYNAPSE", "")
+        self.password = self.env.get("PASSWORD", "")
         self._private_key = self._load_private_key()
         self._public_key = self._load_public_key()
 
@@ -34,110 +35,39 @@ class Node:
             "password": self.password,
             "synapse": self.synapse
         }
+    
 
-
-    def _load_private_key(self):
-        try:
-            with open(self.private_key_path, "rb") as f:
-                private_key = serialization.load_pem_private_key(
-                    f.read(),
-                    password=None,
-                    backend=default_backend()
-                )
-                return private_key
-        except FileNotFoundError:
-            print(f"Private key file not found at {self.private_key_path}.")
-            return None
-        
-
-    def _load_host(self):
-        credentials_folder_path = Path.home() / ".neuronum"
-        env_path = credentials_folder_path / ".env"
-
-        env_data = {}  
-
-        try:
-            with open(env_path, "r") as f:
-                for line in f:
-                    key, value = line.strip().split("=")
-                    env_data[key] = value
-
-            host = env_data.get("HOST", "")
-            return host
-        except FileNotFoundError:
-            print(f"Cell Host not found")
-            return None
-        
-
-    def _load_password(self):
-        credentials_folder_path = Path.home() / ".neuronum"
-        env_path = credentials_folder_path / ".env"
-
-        env_data = {}  
-
-        try:
-            with open(env_path, "r") as f:
-                for line in f:
-                    key, value = line.strip().split("=")
-                    env_data[key] = value
-
-            host = env_data.get("PASSWORD", "")
-            return host
-        except FileNotFoundError:
-            print(f"Cell Password not found")
-            return None
-        
-    def _load_synapse(self):
+    def _load_env(self) -> dict:
         credentials_folder_path = Path.home() / ".neuronum"
         env_path = credentials_folder_path / ".env"
-
-        env_data = {}  
-
+        env_data = {}
         try:
             with open(env_path, "r") as f:
                 for line in f:
                     key, value = line.strip().split("=")
                     env_data[key] = value
-
-            host = env_data.get("SYNAPSE", "")
-            return host
+            return env_data
         except FileNotFoundError:
-            print(f"Cell Synapse not found")
-            return None
-        
-    def _load_network(self):
-        credentials_folder_path = Path.home() / ".neuronum"
-        env_path = credentials_folder_path / ".env"
+            print(f"Cell credentials (.env) not found at {env_path}")
+            return {}
 
-        env_data = {}  
 
+    def _load_private_key(self):
         try:
-            with open(env_path, "r") as f:
-                for line in f:
-                    key, value = line.strip().split("=")
-                    env_data[key] = value
-
-            host = env_data.get("NETWORK", "")
-            return host
+            with open(self.private_key_path, "rb") as f:
+                return serialization.load_pem_private_key(f.read(), password=None, backend=default_backend())
         except FileNotFoundError:
-            print(f"Cell Network not found")
+            print(f"Private key file not found at {self.private_key_path}.")
             return None
 
 
     def _load_public_key(self):
         try:
             with open(self.public_key_path, "rb") as f:
-                public_key = serialization.load_pem_public_key(
-                    f.read(),
-                    backend=default_backend()
-                )
-                return public_key
+                return serialization.load_pem_public_key(f.read(), backend=default_backend())
         except FileNotFoundError:
-            print(f"Public key file not found at {self.public_key_path}. Deriving from private key.")
-            if self._private_key:
-                return self._private_key.public_key()
-            else:
-                return None
+            print(f"Public key file not found. Deriving from private key.")
+            return self._private_key.public_key() if self._private_key else None
 
 
     def get_public_key_jwk(self):
@@ -145,44 +75,167 @@ class Node:
         if not public_key:
             print("Public key not loaded. Cannot generate JWK.")
             return None
-        
         public_numbers = public_key.public_numbers()
-        
         x_bytes = public_numbers.x.to_bytes((public_numbers.x.bit_length() + 7) // 8, 'big')
         y_bytes = public_numbers.y.to_bytes((public_numbers.y.bit_length() + 7) // 8, 'big')
-        
         return {
             "kty": "EC",
             "crv": "P-256",
             "x": base64.urlsafe_b64encode(x_bytes).rstrip(b'=').decode('utf-8'),
             "y": base64.urlsafe_b64encode(y_bytes).rstrip(b'=').decode('utf-8')
         }
-    
-  
+
+
     def _decrypt_with_ecdh_aesgcm(self, ephemeral_public_key_bytes, nonce, ciphertext):
         try:
             ephemeral_public_key = ec.EllipticCurvePublicKey.from_encoded_point(
                 ec.SECP256R1(), ephemeral_public_key_bytes
             )
-
             shared_secret = self._private_key.exchange(ec.ECDH(), ephemeral_public_key)
-            
-            derived_key = HKDF(
-                algorithm=hashes.SHA256(),
-                length=32,
-                salt=None,
-                info=b'handshake data'
-            ).derive(shared_secret)
-
+            derived_key = HKDF(algorithm=hashes.SHA256(), length=32, salt=None, info=b'handshake data').derive(shared_secret)
             aesgcm = AESGCM(derived_key)
             plaintext_bytes = aesgcm.decrypt(nonce, ciphertext, None)
             return json.loads(plaintext_bytes.decode())
-            
         except Exception as e:
             print(f"Decryption failed: {e}")
             return None
 
 
+    def _encrypt_with_ecdh_aesgcm(self, public_key, plaintext_dict):
+        ephemeral_private = ec.generate_private_key(ec.SECP256R1())
+        shared_secret = ephemeral_private.exchange(ec.ECDH(), public_key)
+        derived_key = HKDF(algorithm=hashes.SHA256(), length=32, salt=None, info=b'handshake data').derive(shared_secret)
+        aesgcm = AESGCM(derived_key)
+        nonce = os.urandom(12)
+        plaintext_bytes = json.dumps(plaintext_dict).encode()
+        ciphertext = aesgcm.encrypt(nonce, plaintext_bytes, None)
+        ephemeral_public_bytes = ephemeral_private.public_key().public_bytes(
+            serialization.Encoding.X962, serialization.PublicFormat.UncompressedPoint
+        )
+        return {
+            'ciphertext': base64.urlsafe_b64encode(ciphertext).rstrip(b'=').decode(),
+            'nonce': base64.urlsafe_b64encode(nonce).rstrip(b'=').decode(),
+            'ephemeralPublicKey': base64.urlsafe_b64encode(ephemeral_public_bytes).rstrip(b'=').decode()
+        }
+
+
+    def _load_public_key_from_jwk(self, jwk):
+        try:
+            x_bytes = base64.urlsafe_b64decode(jwk['x'] + '==')
+            y_bytes = base64.urlsafe_b64decode(jwk['y'] + '==')
+            public_numbers = ec.EllipticCurvePublicNumbers(
+                int.from_bytes(x_bytes, 'big'),
+                int.from_bytes(y_bytes, 'big'),
+                ec.SECP256R1()
+            )
+            return public_numbers.public_key(default_backend())
+        except Exception as e:
+            print(f"Error loading public key from JWK: {e}")
+            return None
+
+
+    def _load_public_key_from_pem(self, pem_string: str):
+        try:
+            corrected_pem = pem_string.replace("-----BEGINPUBLICKEY-----", "-----BEGIN PUBLIC KEY-----") \
+                                      .replace("-----ENDPUBLICKEY-----", "-----END PUBLIC KEY-----")
+            public_key = serialization.load_pem_public_key(corrected_pem.encode(), backend=default_backend())
+            return public_key
+        except Exception as e:
+            print(f"Error loading public key from PEM: {e}")
+            return None
+
+
+    async def _get_target_node_public_key(self, node_id: str):
+        nodes = await self.list_nodes()
+        for node in nodes:
+            app_metadata = node.get('config', {}).get('app_metadata', {})
+            if app_metadata.get('node_id') == node_id:
+                pem = node.get('config', {}).get('public_key')
+                if not pem:
+                    print(f"Public key missing for node: {node_id}")
+                    return None
+                public_key = self._load_public_key_from_pem(pem)
+                if not public_key:
+                    return None
+                return public_key
+        print(f"Target node not found: {node_id}")
+        return None
+
+
+    async def _post_request(self, url, payload):
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.post(url, json=payload) as response:
+                    response.raise_for_status()
+                    return await response.json()
+            except aiohttp.ClientError as e:
+                print(f"HTTP Error: {e.status}, URL: {url}")
+            except Exception as e:
+                print(f"Unexpected error: {e}")
+        return None
+
+
+    async def list_nodes(self):
+        full_url = f"https://{self.network}/api/list_nodes"
+        payload = {"cell": self.to_dict()}
+        data = await self._post_request(full_url, payload)
+        return data.get("Nodes", []) if data else []
+
+
+    async def tx_response(self, transmitter_id: str, data: dict, client_public_key_str: Optional[Union[str, dict]] = None, encrypted: Optional[bool] = True):
+        url = f"https://{self.network}/api/tx_response/{transmitter_id}"
+        
+        if encrypted:
+            if not client_public_key_str:
+                print("Error: client_public_key_str is required for encrypted responses.")
+                return
+
+            public_key_jwk = json.loads(client_public_key_str) if isinstance(client_public_key_str, str) else client_public_key_str
+            public_key = self._load_public_key_from_jwk(public_key_jwk)
+            if not public_key:
+                return
+
+            encrypted_payload = self._encrypt_with_ecdh_aesgcm(public_key, data)
+            payload = {"data": encrypted_payload, "cell": self.to_dict()}
+        else:
+            payload = {"data": data, "cell": self.to_dict()}
+        
+        await self._post_request(url, payload)
+
+
+    async def activate_tx(self, node_id: str, data: dict, encrypted: Optional[bool] = True):
+        url = f"https://{self.network}/api/activate_tx/{node_id}"
+        payload = {"cell": self.to_dict()}
+        
+        if encrypted:
+            public_key = await self._get_target_node_public_key(node_id)
+            if not public_key: return None
+            data_to_encrypt = data.copy()
+            data_to_encrypt["publicKey"] = self.get_public_key_jwk()
+            encrypted_payload = self._encrypt_with_ecdh_aesgcm(public_key, data_to_encrypt)
+            payload["data"] = {"encrypted": encrypted_payload}
+        else:
+            payload["data"] = data
+
+        response_data = await self._post_request(url, payload)
+        
+        if encrypted:
+            if not response_data or "response" not in response_data:
+                print("Unexpected or missing response.")
+                return response_data
+            inner_response = response_data["response"]
+            if "ciphertext" in inner_response:
+                ephemeral_public_key_bytes = base64.urlsafe_b64decode(inner_response["ephemeralPublicKey"] + '==')
+                nonce = base64.urlsafe_b64decode(inner_response["nonce"] + '==')
+                ciphertext = base64.urlsafe_b64decode(inner_response["ciphertext"] + '==')
+                return self._decrypt_with_ecdh_aesgcm(ephemeral_public_key_bytes, nonce, ciphertext)
+            else:
+                print("Server response was not encrypted as expected.")
+                return inner_response
+        else:
+            return response_data
+
+
     async def sync(self) -> AsyncGenerator[str, None]:
         full_url = f"wss://{self.network}/sync/{self.node_id}"
         auth_payload = {
@@ -245,94 +298,67 @@ class Node:
             await asyncio.sleep(3)
 
 
-    async def list_nodes(self):
-        full_url = f"https://{self.network}/api/list_nodes"
-        list_nodes_payload = {
-            "cell": self.to_dict()
-        }
-        async with aiohttp.ClientSession() as session:
-            try:
-                async with session.post(full_url, json=list_nodes_payload) as response:
-                    response.raise_for_status()
-                    data = await response.json()
-                    return data.get("Nodes", [])
-            except aiohttp.ClientError as e:
-                print(f"Error sending request: {e}")
-            except Exception as e:
-                print(f"Unexpected error: {e}")
-  
-
-    def _load_public_key_from_jwk(self, jwk):
-        try:
-            print(jwk)
-            x = base64.urlsafe_b64decode(jwk['x'] + '==')
-            y = base64.urlsafe_b64decode(jwk['y'] + '==')
-            public_numbers = ec.EllipticCurvePublicNumbers(
-                int.from_bytes(x, 'big'),
-                int.from_bytes(y, 'big'),
-                ec.SECP256R1()
-            )
-            return public_numbers.public_key(default_backend())
-        except (KeyError, ValueError, TypeError) as e:
-            print(f"Error loading public key from JWK string: {e}")
-            return None
-
-
-    def _encrypt_with_ecdh_aesgcm(self, public_key, plaintext_dict):
-        ephemeral_private = ec.generate_private_key(ec.SECP256R1())
-        ephemeral_public = ephemeral_private.public_key()
-        shared_secret = ephemeral_private.exchange(ec.ECDH(), public_key)
-        derived_key = HKDF(
-            algorithm=hashes.SHA256(),
-            length=32,
-            salt=None,
-            info=b'handshake data'
-        ).derive(shared_secret)
-        aesgcm = AESGCM(derived_key)
-        nonce = os.urandom(12)
-        plaintext_bytes = json.dumps(plaintext_dict).encode()
-        ciphertext = aesgcm.encrypt(nonce, plaintext_bytes, None)
-        ephemeral_public_bytes = ephemeral_public.public_bytes(
-            serialization.Encoding.X962,
-            serialization.PublicFormat.UncompressedPoint
-        )
-        return {
-            'ciphertext': base64.b64encode(ciphertext).decode(),
-            'nonce': base64.b64encode(nonce).decode(),
-            'ephemeralPublicKey': base64.b64encode(ephemeral_public_bytes).decode()
-        }
-    
-
-    async def tx_response(self, transmitter_id: str, data: dict, client_public_key_str):
-        if isinstance(client_public_key_str, str):
-            try:
-                client_public_key_jwk = json.loads(client_public_key_str)
-            except json.JSONDecodeError:
-                print("Failed to decode client public key from string. Aborting response.")
+    async def stream(self, label: str, data: dict, node_id: str = None, encrypted: Optional[bool] = True, retry_delay: int = 3):
+        context = ssl.create_default_context()
+        context.check_hostname = True
+        context.verify_mode = ssl.CERT_REQUIRED
+        
+        target_node_public_key = None
+        if encrypted:
+            target_node_public_key = await self._get_target_node_public_key(node_id)
+            if not target_node_public_key:
+                print("Failed to get target node's public key. Cannot stream data.")
                 return
-        elif isinstance(client_public_key_str, dict):
-            client_public_key_jwk = client_public_key_str
-        else:
-            print("Invalid type for client public key. Expected str or dict. Aborting response.")
-            return
-        public_key = self._load_public_key_from_jwk(client_public_key_jwk)
-        if not public_key:
-            print("Failed to load public key. Aborting response.")
-            return
-        encrypted_payload = self._encrypt_with_ecdh_aesgcm(public_key, data)
-        url = f"https://{self.network}/api/tx_response/{transmitter_id}"
-        tx_response = {
-            "data": encrypted_payload,
-            "cell": self.to_dict()
-        }
-        async with aiohttp.ClientSession() as session:
+
+        while True:
             try:
-                for _ in range(2):
-                    async with session.post(url, json=tx_response) as response:
-                        response.raise_for_status()
-                        data = await response.json()
-                print(data["message"])
-            except aiohttp.ClientError as e:
-                print(f"Error sending request: {e}")
+                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{node_id}\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.copy()
+                }
+                
+                if encrypted:
+                    data_to_encrypt = data.copy()
+                    data_to_encrypt["publicKey"] = self.get_public_key_jwk()
+                    
+                    encrypted_payload = self._encrypt_with_ecdh_aesgcm(target_node_public_key, data_to_encrypt)
+                    stream_payload["data"] = {"encrypted": encrypted_payload}
+
+                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}")
+                print(f"Unexpected error: {e}, retrying...")
+                await asyncio.sleep(retry_delay)
+            finally:
+                if 'writer' in locals():
+                    writer.close()
+                    await writer.wait_closed()

{neuronum-8.3.0.dist-info → neuronum-9.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuronum
-Version: 8.3.0
+Version: 9.0.0
 Summary: The E2E Web Engine
 Home-page: https://neuronum.net
 Author: Neuronum Cybernetics

neuronum-9.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/main.py,sha256=Ol3kyxh7odt03buze27PGCCaDS0iOax8nbTWYHvK1pA,31798
+neuronum/__init__.py,sha256=qkAz6fpiS2KKnaKwPbS15y7lRCQV-XaWNTkVUarluPk,26
+neuronum/neuronum.py,sha256=3Sway-04-Yb3PHcnbIVumL0kQMB__fiO5w9vDXbkWGk,16186
+neuronum-9.0.0.dist-info/licenses/LICENSE.md,sha256=m7pw_FktMNCs4tcy2UXP3QQP2S_je28P1SepdYoo0Xo,1961
+neuronum-9.0.0.dist-info/METADATA,sha256=UIovNeYOTcpaZz0FUhJvWQ5EqIu7dDvVpxgrxu8DTWM,3448
+neuronum-9.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+neuronum-9.0.0.dist-info/entry_points.txt,sha256=XKYBcRNxGeJpZZkDPsa8HA_RaJ7Km_R_JaUq5T9Nk2U,42
+neuronum-9.0.0.dist-info/top_level.txt,sha256=ru8Fr84cHm6oHr_DcJ8-uaq3RTiuCRFIr6AC8V0zPu4,13
+neuronum-9.0.0.dist-info/RECORD,,

neuronum-8.3.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cli/main.py,sha256=rsr2vt0qQjb0IX6V4-s5RkApZz5FPnoPuxuZXMtUlUM,31799
-neuronum/__init__.py,sha256=qkAz6fpiS2KKnaKwPbS15y7lRCQV-XaWNTkVUarluPk,26
-neuronum/neuronum.py,sha256=4iZjeQ1XTKPhUpojmpkYQiOaNZPZE6t7JUyhLPMOyuA,13183
-neuronum-8.3.0.dist-info/licenses/LICENSE.md,sha256=m7pw_FktMNCs4tcy2UXP3QQP2S_je28P1SepdYoo0Xo,1961
-neuronum-8.3.0.dist-info/METADATA,sha256=FXfumz1JVjicIaNHN4boBYy85m3FwuDkrrZCYbCyYhc,3448
-neuronum-8.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-neuronum-8.3.0.dist-info/entry_points.txt,sha256=XKYBcRNxGeJpZZkDPsa8HA_RaJ7Km_R_JaUq5T9Nk2U,42
-neuronum-8.3.0.dist-info/top_level.txt,sha256=ru8Fr84cHm6oHr_DcJ8-uaq3RTiuCRFIr6AC8V0zPu4,13
-neuronum-8.3.0.dist-info/RECORD,,