astreum 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

astreum/node/__init__.py

@@ -1,8 +1,11 @@
 import os
 import hashlib
 import time
-from typing import Tuple, Optional
+import threading
+import random
+from typing import Tuple, Optional, List
 import json
+from cryptography.hazmat.primitives.asymmetric import ed25519
 
 from .relay import Relay, Topic
 from .relay.peer import Peer
@@ -15,9 +18,33 @@ class Node:
     def __init__(self, config: dict):
         # Ensure config is a dictionary, but allow it to be None
         self.config = config if config is not None else {}
+        
+        # Handle validation key if provided
+        self.validation_private_key = None
+        self.validation_public_key = None
+        self.is_validator = False
+        
+        # Extract validation private key from config
+        if 'validation_private_key' in self.config:
+            try:
+                key_bytes = bytes.fromhex(self.config['validation_private_key'])
+                self.validation_private_key = ed25519.Ed25519PrivateKey.from_private_bytes(key_bytes)
+                self.validation_public_key = self.validation_private_key.public_key()
+                self.is_validator = True
+                
+                # Set validation_route to True in config so relay will join validation route
+                self.config['validation_route'] = True
+                print(f"Node is configured as a validator with validation key")
+            except Exception as e:
+                print(f"Error loading validation private key: {e}")
+        
+        # Initialize relay with our config
         self.relay = Relay(self.config)
-        # Get the node_id from relay instead of generating our own
+        
+        # Get the node_id from relay
         self.node_id = self.relay.node_id
+        
+        # Initialize storage
         self.storage = Storage(self.config)
         self.storage.node = self  # Set the storage node reference to self
         
@@ -46,6 +73,84 @@ class Node:
         # Candidate chains that might be adopted
         self.candidate_chains = {}  # chain_id -> {'latest_block': block, 'timestamp': time.time()}
         
+        # Block query timers for different routes
+        self.running = False
+        self.block_query_threads = []
+        
+    def start(self):
+        """Start the node and all its services."""
+        self.running = True
+        
+        # Start periodic block query thread for validation route
+        validation_query_thread = threading.Thread(
+            target=self._periodic_validation_route_query, 
+            daemon=True
+        )
+        validation_query_thread.start()
+        self.block_query_threads.append(validation_query_thread)
+        
+        print(f"Node started with ID {self.node_id.hex()}")
+        print(f"Listening on port {self.relay.incoming_port}")
+        
+    def stop(self):
+        """Stop the node and all its services."""
+        self.running = False
+        
+        # Stop all threads
+        for thread in self.block_query_threads:
+            if thread.is_alive():
+                thread.join(timeout=1.0)  # Give threads 1 second to shut down
+                
+        print("Node stopped")
+        
+    def _periodic_validation_route_query(self):
+        """Periodically query random peers in the validation route for latest blocks."""
+        while self.running:
+            try:
+                # Query 3 random peers from validation route for latest block
+                self._query_random_peers_for_latest_block(route_type=1, count=3)
+                
+                # Prune old candidate chains periodically
+                self._prune_candidate_chains()
+                
+                # Sleep according to validator status
+                if self.is_validator:
+                    # Validators check more frequently (every second)
+                    time.sleep(1)
+                else:
+                    # Regular nodes check less frequently (every 3 seconds)
+                    time.sleep(3)
+            except Exception as e:
+                print(f"Error in validation route query: {e}")
+                time.sleep(1)  # Sleep briefly before retrying
+                
+    def _query_random_peers_for_latest_block(self, route_type: int, count: int = 3):
+        """
+        Query random peers from specified route for latest block.
+        
+        Args:
+            route_type (int): Route type (0 for peer, 1 for validation)
+            count (int): Number of random peers to query
+        """
+        # Only continue if we're tracking this route
+        if not self.relay.is_tracking_route(route_type):
+            return
+            
+        # Get random peers from the route
+        random_peers = self.relay.get_random_peers_from_route(route_type, count)
+        
+        # Query each peer for latest block
+        for peer in random_peers:
+            try:
+                # Create empty request message
+                request_data = b''
+                
+                # Send request to peer
+                addr = (peer.ip, peer.port)
+                self.relay.send_message(request_data, Topic.LATEST_BLOCK_REQUEST, addr)
+            except Exception as e:
+                print(f"Error querying peer {peer.node_id.hex()}: {e}")
+    
     def _handle_ping(self, body: bytes, addr: Tuple[str, int], envelope):
         """
         Handle ping messages by storing peer info and responding with a pong.
@@ -358,10 +463,7 @@ class Node:
         in chain is in the previous field.
         """
         try:
-            # Check if we're in the validation route
-            # This is now already checked by the relay's _handle_message method
-            if not self.relay.is_in_validation_route():
-                return
+            # All nodes can process latest blocks now, regardless of route membership
             
             # Deserialize the block
             block = Block.from_bytes(body)
@@ -374,71 +476,91 @@ class Node:
                 if not self.followed_chain_id or block.chain_id != self.followed_chain_id:
                     self._add_candidate_chain(block)
                 return
-            
-            # Get our current latest block
-            our_latest = self.latest_block
-            
-            # Verify block hash links to our latest block
-            if our_latest and block.previous_hash == our_latest.hash:
-                # Process the valid block
-                self.machine.process_block(block)
                 
-                # Update our latest block
-                self.latest_block = block
-            # Check if this block is ahead of our current chain
-            elif our_latest and block.height > our_latest.height:
-                # Block is ahead but doesn't link directly to our latest
-                # Add to candidate chains for potential future adoption
-                self._add_candidate_chain(block)
-            
-            # No automatic broadcasting - nodes will request latest blocks when needed
+            # Only proceed if block chain_id matches what we're following
+            if self.followed_chain_id and block.chain_id != self.followed_chain_id:
+                return
+                
+            if not self.latest_block:
+                # We don't have a latest block, so this might be the first one we've seen
+                # Store it as our latest
+                self._update_latest_block(block)
+                return
+                
+            # If this block is newer than our latest, update our latest block
+            if block.height > self.latest_block.height:
+                # Verify chain continuity
+                if self.latest_block.hash_bytes in block.previous_blocks:
+                    # This is a valid continuation of our chain
+                    self._update_latest_block(block)
+                else:
+                    # This block doesn't build on our latest, check for forking
+                    # but continue tracking it as a candidate
+                    self._add_candidate_chain(block)
+                    
         except Exception as e:
             print(f"Error handling latest block: {e}")
     
     def _handle_transaction(self, body: bytes, addr: Tuple[str, int], envelope):
         """
-        Handle receipt of a transaction.
-        Accept if validation route is present and counter is valid relative to the latest block in our chain.
+        Handle incoming transaction messages.
+        
+        This method is called when we receive a transaction from the network.
+        Transactions should only be processed by validator nodes.
+        
+        Args:
+            body: Transaction data
+            addr: Source address
+            envelope: Full message envelope
         """
+        # Ignore if we're not a validator (don't have a validation key)
+        if not self.is_validator or not self.relay.is_in_validation_route():
+            print("Ignoring transaction as we're not a validator")
+            return
+            
         try:
-            # Check if we're in the validation route
-            # This is now already checked by the relay's _handle_message method
-            if not self.relay.is_in_validation_route():
-                return
+            # Parse transaction data
+            tx_data = json.loads(body.decode('utf-8'))
             
-            # Deserialize the transaction
-            transaction = Transaction.from_bytes(body)
-            if not transaction:
-                return
-                
-            # Check if we're following this chain
-            if not self.machine.is_following_chain(transaction.chain_id):
-                return
-                
-            # Verify transaction has a valid validation route
-            if not transaction.has_valid_route():
-                return
-                
-            # Get latest block from this chain
-            latest_block = self.machine.get_latest_block(transaction.chain_id)
-            if not latest_block:
-                return
-                
-            # Verify transaction counter is valid relative to the latest block
-            if not transaction.is_counter_valid(latest_block):
-                return
+            # Store the transaction in our local storage
+            tx_hash = bytes.fromhex(tx_data.get('hash'))
+            tx_raw = bytes.fromhex(tx_data.get('data'))
+            
+            # Create transaction entry in storage
+            if not self.storage.contains(tx_hash):
+                self.storage.put(tx_hash, tx_raw)
+                print(f"Stored transaction {tx_hash.hex()}")
                 
-            # Process the valid transaction
-            self.machine.process_transaction(transaction)
-            
-            # Relay to other peers in the validation route
-            validation_peers = self.relay.get_route_peers(1)  # 1 = validation route
-            for peer in validation_peers:
-                if peer.address != addr:  # Don't send back to originator
-                    self.relay.send_message(body, Topic.TRANSACTION, peer.address)
+                # Process the transaction as a validator
+                self._process_transaction_as_validator(tx_hash, tx_raw)
+            
         except Exception as e:
             print(f"Error handling transaction: {e}")
             
+    def _process_transaction_as_validator(self, tx_hash: bytes, tx_raw: bytes):
+        """
+        Process a transaction as a validator node.
+        
+        This method is called when we receive a transaction and we're a validator.
+        It verifies the transaction and may include it in a future block.
+        
+        Args:
+            tx_hash: Transaction hash
+            tx_raw: Raw transaction data
+        """
+        try:
+            print(f"Processing transaction {tx_hash.hex()} as validator")
+            # Here we would verify the transaction and potentially queue it
+            # for inclusion in the next block we create
+            
+            # For now, just log that we processed it
+            print(f"Verified transaction {tx_hash.hex()}")
+            
+            # TODO: Implement transaction validation and queueing for block creation
+            
+        except Exception as e:
+            print(f"Error processing transaction as validator: {e}")
+            
     def _initialize_latest_block(self):
         """Initialize latest block from storage if available."""
         # Implementation would load the latest block from storage
@@ -465,17 +587,19 @@ class Node:
     
     def _add_candidate_chain(self, block):
         """
-        Add a block to candidate chains for potential future adoption.
+        Add a block to the candidate chains.
         
         Args:
-            block: The block to add as a candidate
+            block: Block to add
         """
         chain_id = block.chain_id
         
-        # If we already have this chain as a candidate, only update if this block is newer
+        # Check if we already have this chain as a candidate
         if chain_id in self.candidate_chains:
-            current_candidate = self.candidate_chains[chain_id]['latest_block']
-            if block.height > current_candidate.height:
+            existing_block = self.candidate_chains[chain_id]['latest_block']
+            
+            # Only update if this block is newer
+            if block.height > existing_block.height:
                 self.candidate_chains[chain_id] = {
                     'latest_block': block,
                     'timestamp': time.time()
@@ -486,10 +610,34 @@ class Node:
                 'latest_block': block,
                 'timestamp': time.time()
             }
+            
+        print(f"Added candidate chain {chain_id.hex()} with height {block.height}")
+    
+    def _update_latest_block(self, block):
+        """
+        Update our latest block and process it.
         
-        # Prune old candidates (older than 1 hour)
-        self._prune_candidate_chains()
-        
+        Args:
+            block: New latest block to set
+        """
+        # Process the block if it's new
+        if not self.latest_block or block.hash_bytes != self.latest_block.hash_bytes:
+            # Process block logic in the machine
+            self.machine.process_block(block)
+            
+            # Update our latest block reference
+            self.latest_block = block
+            
+            # Update followed chain ID if needed
+            if not self.followed_chain_id:
+                self.followed_chain_id = block.chain_id
+                
+            print(f"Updated latest block to height {block.height}, hash {block.hash}")
+            
+            # Save latest block to storage for persistence
+            if self.storage:
+                self.storage.put_latest_block(block)
+                
     def _prune_candidate_chains(self):
         """Remove candidate chains that are older than 1 hour."""
         current_time = time.time()

astreum/node/relay/__init__.py

@@ -4,6 +4,8 @@ Relay module for handling network communication in the Astreum node.
 
 import socket
 import threading
+import random
+import time
 from queue import Queue
 from typing import Tuple, Callable, Dict, Set, Optional, List
 from .message import Message, Topic
@@ -24,10 +26,10 @@ class Relay:
         self.num_workers = config.get('num_workers', 4)
 
         # Generate Ed25519 keypair for this node
-        if 'private_key' in config:
+        if 'relay_private_key' in config:
             # Load existing private key if provided
             try:
-                private_key_bytes = bytes.fromhex(config['private_key'])
+                private_key_bytes = bytes.fromhex(config['relay_private_key'])
                 self.private_key = ed25519.Ed25519PrivateKey.from_private_bytes(private_key_bytes)
             except Exception as e:
                 print(f"Error loading private key: {e}, generating new one")
@@ -43,12 +45,16 @@ class Relay:
         # Save private key bytes for config persistence
         self.private_key_bytes = self.private_key.private_bytes_raw()
 
-        # Routes that this node participates in (0 = peer route, 1 = validation route)
+        # Routes that this node participates in 
+        # 0 = peer route, 1 = validation route
+        # All routes are tracked by default, but we only join some
         self.routes: List[int] = []
+        self.tracked_routes: List[int] = [0, 1]  # Track all routes
         
-        # Peer route is always enabled
+        # Always join peer route
         self.routes.append(0)  # Peer route
             
+        # Check if this node should join validation route
         if config.get('validation_route', False):
             self.routes.append(1)  # Validation route
 
@@ -100,44 +106,53 @@ class Relay:
     def is_in_validation_route(self) -> bool:
         """Check if this node is part of the validation route."""
         return 1 in self.routes
+    
+    def is_tracking_route(self, route_type: int) -> bool:
+        """Check if this node is tracking a specific route."""
+        return route_type in self.tracked_routes
         
-    def add_to_peer_route(self):
-        """Add this node to the peer route."""
-        if 0 not in self.routes:
-            self.routes.append(0)
+    def get_random_peers_from_route(self, route_type: int, count: int = 3) -> List[Peer]:
+        """
+        Get a list of random peers from different buckets in the specified route.
         
-    def add_to_validation_route(self):
-        """Add this node to the validation route."""
-        if 1 not in self.routes:
-            self.routes.append(1)
+        Args:
+            route_type (int): Route type (0 for peer, 1 for validation)
+            count (int): Number of random peers to select (one from each bucket)
+            
+        Returns:
+            List[Peer]: List of randomly selected peers from different buckets
+        """
+        result = []
+        route_id = self._get_route_id(route_type)
         
-    def remove_from_peer_route(self):
-        """Remove this node from the peer route."""
-        if 0 in self.routes:
-            self.routes.remove(0)
+        # Get all buckets that have peers for this route
+        buckets_with_peers = []
+        for i, bucket in enumerate(self.routing_table):
+            # For each bucket, collect peers that are in this route
+            route_peers_in_bucket = [peer for peer in bucket.values() 
+                                    if peer.routes and route_id in peer.routes]
+            if route_peers_in_bucket:
+                buckets_with_peers.append((i, route_peers_in_bucket))
         
-    def remove_from_validation_route(self):
-        """Remove this node from the validation route."""
-        if 1 in self.routes:
-            self.routes.remove(1)
+        # If we don't have any buckets with peers, return empty list
+        if not buckets_with_peers:
+            return []
         
-    def add_peer_to_route(self, peer: Peer, route_types: List[int]):
-        """
-        Add a peer to specified routes.
+        # If we have fewer buckets than requested count, adjust count
+        sample_count = min(count, len(buckets_with_peers))
         
-        Args:
-            peer (Peer): The peer to add
-            route_types (List[int]): List of route types to add the peer to (0 = peer, 1 = validation)
-        """
-        for route_type in route_types:
-            if route_type == 0:  # Peer route
-                # Add to top of bucket, eject last if at capacity
-                self.peer_route_bucket.add(peer, to_front=True)
-            elif route_type == 1:  # Validation route
-                # Add to top of bucket, eject last if at capacity
-                self.validation_route_bucket.add(peer, to_front=True)
+        # Sample random buckets
+        selected_buckets = random.sample(buckets_with_peers, sample_count)
+        
+        # For each selected bucket, pick one random peer
+        for bucket_idx, peers in selected_buckets:
+            # Select one random peer from this bucket
+            selected_peer = random.choice(peers)
+            result.append(selected_peer)
             
-    def get_route_peers(self, route_type: int) -> List[Peer]:
+        return result
+        
+    def get_peers_in_route(self, route_type: int) -> List[Peer]:
         """
         Get all peers in a specific route.
         
@@ -153,6 +168,22 @@ class Relay:
             return self.validation_route_bucket.get_peers()
         return []
         
+    def add_peer_to_route(self, peer: Peer, route_types: List[int]):
+        """
+        Add a peer to specified routes.
+        
+        Args:
+            peer (Peer): The peer to add
+            route_types (List[int]): List of route types to add the peer to (0 = peer, 1 = validation)
+        """
+        for route_type in route_types:
+            if route_type == 0:  # Peer route
+                # Add to top of bucket, eject last if at capacity
+                self.peer_route_bucket.add(peer, to_front=True)
+            elif route_type == 1:  # Validation route
+                # Add to top of bucket, eject last if at capacity
+                self.validation_route_bucket.add(peer, to_front=True)
+            
     def register_message_handler(self, topic: Topic, handler_func):
         """Register a handler function for a specific message topic."""
         self.message_handlers[topic] = handler_func
@@ -215,26 +246,19 @@ class Relay:
         """Handle an incoming message."""
         envelope = Envelope.from_bytes(data)
         if envelope and envelope.message.topic in self.message_handlers:
-            # Check if this is a transaction or block message that requires validation route
-            if envelope.message.topic in (Topic.TRANSACTION, Topic.BLOCK):
-                # Only process if we're part of the validation route
+            # For transaction messages, only process if we're in validation route
+            if envelope.message.topic == Topic.TRANSACTION:
                 if self.is_in_validation_route():
                     self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
-            elif envelope.message.topic == Topic.LATEST_BLOCK:
-                # For latest_block, we only process if we're in the validation route
+            # For block messages, only process if we're in validation route
+            elif envelope.message.topic == Topic.BLOCK:
                 if self.is_in_validation_route():
                     self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
-            elif envelope.message.topic in (Topic.LATEST_BLOCK_REQUEST, Topic.GET_BLOCKS):
-                # Allow all nodes to request blocks for syncing
-                self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
-            elif envelope.message.topic == Topic.OBJECT_REQUEST:
-                # Handle object request
-                self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
-            elif envelope.message.topic == Topic.OBJECT_RESPONSE:
-                # Handle object response
+            # Latest block and latest block requests can be handled by any node tracking the routes
+            elif envelope.message.topic in (Topic.LATEST_BLOCK, Topic.LATEST_BLOCK_REQUEST):
                 self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
+            # For other message types, always process
             else:
-                # For other message types, always process
                 self.message_handlers[envelope.message.topic](envelope.message.body, addr, envelope)
 
     def send(self, data: bytes, addr: Tuple[str, int]):

{astreum-0.1.12.dist-info → astreum-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: astreum
-Version: 0.1.12
+Version: 0.1.14
 Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib
@@ -28,7 +28,8 @@ When initializing an Astreum Node, you need to provide a configuration dictionar
 
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
-| `private_key` | string | Auto-generated | Hex string of Ed25519 private key. If not provided, a new keypair will be generated automatically |
+| `relay_private_key` | string | Auto-generated | Hex string of Ed25519 private key for network identity. If not provided, a new keypair will be generated automatically |
+| `validation_private_key` | string | None | Hex string of Ed25519 private key for block validation. If provided, the node will join the validation route automatically |
 | `storage_path` | string | "storage" | Path to store data |
 | `max_storage_space` | int | 1073741824 (1GB) | Maximum storage space in bytes |
 | `max_object_recursion` | int | 50 | Maximum recursion depth for resolving nested objects |
@@ -47,7 +48,7 @@ When initializing an Astreum Node, you need to provide a configuration dictionar
 
 | Parameter | Type | Default | Description |
 |-----------|------|---------|-------------|
-| `validation_route` | bool | False | Whether to participate in the block validation route |
+| `validation_route` | bool | False | Whether to participate in the block validation route (automatically set to True if validation_private_key is provided) |
 | `bootstrap_peers` | list | [] | List of bootstrap peers in the format `[("hostname", port), ...]` |
 
 > **Note:** The peer route is always enabled as it's necessary for object discovery and retrieval.
@@ -59,12 +60,11 @@ from astreum.node import Node
 
 # Configuration dictionary
 config = {
-    "private_key": "my-private-key-goes-here",
+    "relay_private_key": "relay-private-key-hex-string",
+    "validation_private_key": "validation-private-key-hex-string",  # Optional, for validator nodes
     "storage_path": "./data/node1",
     "incoming_port": 7373,
     "use_ipv6": False,
-    "peer_route": True,
-    "validation_route": True,
     "bootstrap_peers": [
         ("bootstrap.astreum.org", 7373),
         ("127.0.0.1", 7374)

{astreum-0.1.12.dist-info → astreum-0.1.14.dist-info}/RECORD

@@ -20,9 +20,9 @@ astreum/lispeum/special/number/addition.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 astreum/machine/__init__.py,sha256=GOdZl1tS9uIJHbq5WVcplifMDPDLQroX7CVew-K2YbA,15262
 astreum/machine/environment.py,sha256=K0084U6B7wwjrDZ9b2_7cEcbBzsB7UOy_Zpbrr7B3GY,834
 astreum/machine/error.py,sha256=MvqBaZZt33rNELNhUJ2lER3TE3aS8WVqsWF2hz2AwoA,38
-astreum/node/__init__.py,sha256=EdGMa9pargAdB7KzjKBkhuFJ3G3wZF2VeIGkYFOCLws,22497
+astreum/node/__init__.py,sha256=Zvu7_oadjB8V3TQpDR9pTdURXZpcHKI5Qhxz4Ykep7U,28271
 astreum/node/models.py,sha256=9Uf2_u55uxWG0ujjySvFJUO5Ub-EzlMnnMJWcgJHjHk,11980
-astreum/node/relay/__init__.py,sha256=gQNYDxllkjZqE6bvgPOYkKu3QHkjPFn11RvtP-BxtKI,13994
+astreum/node/relay/__init__.py,sha256=0zvbchIbLUPqGA7QXJbXokKupcIq6Iu3X3VUpxejIQc,14981
 astreum/node/relay/bucket.py,sha256=pcmollbbM-xeHlmDxLZnzvf0Ut-9v9RoN6SijYiQuu8,2893
 astreum/node/relay/envelope.py,sha256=TfkynttoPX7smvMV7xEAdtIlfz-Z-EZjuhZ826csZxA,10078
 astreum/node/relay/message.py,sha256=uezmGjNaQK4fZmYQLCHd2YpiosaaFb8DOa3H58HS1jA,2887
@@ -30,8 +30,8 @@ astreum/node/relay/peer.py,sha256=DlvTR9j0BZQ1dW-p_9UGgfLvQqwNdpNLMSCYEW4FhyI,58
 astreum/node/relay/route.py,sha256=fyOSsAe1mfsCVeN6LtQ_OEUEb1FiC5dobZBEJKNGU9U,5814
 astreum/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/utils/bytes_format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
-astreum-0.1.12.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.1.12.dist-info/METADATA,sha256=LnGyI9YKLRNRWLolnyuHDgg0MKPSyLSwJho4FCTg1to,2942
-astreum-0.1.12.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-astreum-0.1.12.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.1.12.dist-info/RECORD,,
+astreum-0.1.14.dist-info/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.1.14.dist-info/METADATA,sha256=W3SxJCJeN-OxSs_rGNuG1FrqQunyOFYBOlaCZkjlEyk,3261
+astreum-0.1.14.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+astreum-0.1.14.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.1.14.dist-info/RECORD,,