cluster-builder 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

cluster_builder/utils/hcl.py

@@ -1,8 +1,11 @@
+import json
 import os
 import hcl2
 from lark import Tree, Token
+import logging
+import re
 
-
+logger = logging.getLogger("cluster_builder")
 def add_backend_config(backend_tf_path, conn_str, schema_name):
     """
     Adds a PostgreSQL backend configuration to a Terraform file.
@@ -14,7 +17,7 @@ def add_backend_config(backend_tf_path, conn_str, schema_name):
     if os.path.exists(backend_tf_path):
         with open(backend_tf_path) as f:
             if 'backend "pg"' in f.read():
-                print("⚠️  Backend configuration already exists — skipping.")
+                logger.debug("⚠️ Backend config already exists, skipping: %s", backend_tf_path)
                 return
 
     # Build the backend configuration block
@@ -34,7 +37,7 @@ def add_backend_config(backend_tf_path, conn_str, schema_name):
     ) as f:  # Use "w" instead of "a" to create/overwrite the file
         f.write("\n".join(lines) + "\n")
 
-    print(f"✅ Added PostgreSQL backend configuration to {backend_tf_path}")
+    logger.debug("✅ Added PostgreSQL backend config to %s", backend_tf_path)
 
 
 def add_module_block(main_tf_path, module_name, config):
@@ -48,7 +51,7 @@ def add_module_block(main_tf_path, module_name, config):
     if os.path.exists(main_tf_path):
         with open(main_tf_path) as f:
             if f'module "{module_name}"' in f.read():
-                print(f"⚠️  Module '{module_name}' already exists — skipping.")
+                logger.warning("⚠️ Module '%s' already exists, skipping in %s", module_name, main_tf_path)
                 return
 
     # Build the module block
@@ -60,6 +63,8 @@ def add_module_block(main_tf_path, module_name, config):
             v_str = "true" if v else "false"
         elif isinstance(v, (int, float)):
             v_str = str(v)
+        elif isinstance(v, (list, dict)):
+            v_str = json.dumps(v)
         elif v is None:
             continue
         else:
@@ -71,40 +76,51 @@ def add_module_block(main_tf_path, module_name, config):
     with open(main_tf_path, "a") as f:
         f.write("\n\n" + "\n".join(lines) + "\n")
 
-    print(f"✅ Added module '{module_name}' to {main_tf_path}")
+    logger.debug("✅ Added module '%s' to %s", module_name, main_tf_path)
 
 
 def is_target_module_block(tree: Tree, module_name: str) -> bool:
     """
     Check if the tree is a module block with the specified name.
     """
+    logger.info(f"Checking tree with data: {tree.data}, children count: {len(tree.children)}")
+    logger.info(f"Children types and values: {[ (type(c), getattr(c, 'value', None)) for c in tree.children ]}")
+
     if tree.data != "block":
+        logger.debug(f"Rejected: tree.data is '{tree.data}', expected 'block'")
         return False
 
     # Need at least 3 children: identifier, name, body
     if len(tree.children) < 3:
+        logger.debug(f"Rejected: tree has less than 3 children ({len(tree.children)})")
         return False
 
     # First child should be an identifier tree
     first_child = tree.children[0]
     if not isinstance(first_child, Tree) or first_child.data != "identifier":
+        logger.debug(f"Rejected: first child is not an identifier Tree (found {type(first_child)} with data '{getattr(first_child, 'data', None)}')")
         return False
 
     # First child should have a NAME token with 'module'
     if len(first_child.children) == 0 or not isinstance(first_child.children[0], Token):
+        logger.debug("Rejected: first child has no Token children")
         return False
 
-    if first_child.children[0].value != "module":
+    first_value = first_child.children[0].value
+    if first_value != "module":
+        logger.debug(f"Rejected: first child token value '{first_value}' is not 'module'")
         return False
 
-    # Second child should be a STRING_LIT token with module name
+    # Second child: could be a Token or Tree with Token child for module name
     second_child = tree.children[1]
+
     if not isinstance(second_child, Token) or second_child.value != f'"{module_name}"':
+        logger.debug(f"Second child check failed: type={type(second_child)}, value={getattr(second_child, 'value', None)} expected=\"{module_name}\"")
         return False
 
+    logger.info(f"Module block matched for module name '{module_name}'")
     return True
 
-
 def simple_remove_module(tree, module_name, removed=False):
     """
     A simpler function to remove module blocks that maintains the exact Tree structure
@@ -116,6 +132,9 @@ def simple_remove_module(tree, module_name, removed=False):
         body_node = tree.children[0]
 
         if isinstance(body_node, Tree) and body_node.data == "body":
+            # Debug: Log body node children
+            logger.debug("Body Node Children: %s", body_node.children)
+
             # Create new children list for the body node
             new_body_children = []
             skip_next = False
@@ -133,6 +152,7 @@ def simple_remove_module(tree, module_name, removed=False):
                     and is_target_module_block(child, module_name)
                 ):
                     removed = True
+                    print(f"Module {module_name} found and removed.")  # Debug log
 
                     # Check if the next node is a new_line_or_comment, and skip it as well
                     if i + 1 < len(body_node.children):
@@ -158,14 +178,16 @@ def remove_module_block(main_tf_path, module_name: str):
     Removes a module block by name from main.tf for this cluster.
     """
     if not os.path.exists(main_tf_path):
-        print(f"⚠️  No main.tf found at {main_tf_path}")
+        logger.warning("⚠️ No main.tf found at %s", main_tf_path)
         return
 
     try:
         with open(main_tf_path, "r") as f:
             tree = hcl2.parse(f)
+            # Debug: Log the parsed tree structure
+            logger.debug("Parsed Tree: %s", tree)
     except Exception as e:
-        print(f"❌ Failed to parse HCL: {e}")
+        logger.error("❌ Failed to parse HCL in %s: %s", main_tf_path, e, exc_info=True)
         return
 
     # Process tree to remove target module block
@@ -173,8 +195,11 @@ def remove_module_block(main_tf_path, module_name: str):
 
     # If no modules were removed
     if not removed:
-        print(f"⚠️  No module named '{module_name}' found in {main_tf_path}")
+        logger.warning("⚠️ No module named '%s' found in %s", module_name, main_tf_path)
         return
+    
+    # Debug: Log the final tree structure after removal
+    logger.debug("Final Tree after module removal: %s", new_tree)
 
     try:
         # Reconstruct HCL
@@ -184,9 +209,9 @@ def remove_module_block(main_tf_path, module_name: str):
         with open(main_tf_path, "w") as f:
             f.write(new_source)
 
-        print(f"🗑️  Removed module '{module_name}' from {main_tf_path}")
+        logger.info("🗑️ Removed module '%s' from %s", module_name, main_tf_path)
     except Exception as e:
-        print(f"❌ Failed to reconstruct HCL: {e}")
+        logger.error("❌ Failed to reconstruct HCL in %s: %s", main_tf_path, e, exc_info=True)
         # Print more detailed error information
         import traceback
 
@@ -222,10 +247,61 @@ def extract_template_variables(template_path):
         return variables
 
     except FileNotFoundError:
-        print(f"Warning: Template file not found: {template_path}")
+        logger.warning(f"⚠️ Template file not found: {template_path}")
         return {}
 
     except Exception as e:
         error_msg = f"Failed to extract variables from {template_path}: {e}"
-        print(f"Error: {error_msg}")
+        logger.error(f"❌ {error_msg}")
         raise ValueError(error_msg)
+
+def add_output_blocks(outputs_tf_path, module_name, output_names):
+    existing_text = ""
+    
+    # Read existing content if the file exists
+    if os.path.exists(outputs_tf_path):
+        with open(outputs_tf_path, "r") as f:
+            existing_text = f.read()
+
+    lines_to_add = []
+    updated_lines = []
+
+    # Check and add output blocks
+    for output_name in output_names:
+        output_block = f'output "{output_name}" {{\n  value = module.{module_name}.{output_name}\n}}'.strip()
+
+        if f'output "{output_name}"' in existing_text:
+            # Check if the output block already exists in the file
+            logger.debug(f"⚠️ Output '{output_name}' already exists in {outputs_tf_path}. Checking if it needs an update.")
+            
+            # Only update if the value is None in the current output
+            if output_name in ["worker_ip", "ha_ip"] and "None" in existing_text:
+                updated_lines.append(output_block)
+            elif output_block not in existing_text:
+                # If it's there but not the same, we need to update it
+                updated_lines.append(output_block)
+            else:
+                logger.debug(f"Output '{output_name}' is already correctly defined in {outputs_tf_path}.")
+            continue
+        else:
+            # If the output doesn't exist, add it
+            lines_to_add.append(output_block)
+
+    # Remove old output blocks before adding or updating new ones
+    if lines_to_add or updated_lines:
+        # Remove old output definitions for those outputs that will be replaced
+        for output_name in output_names:
+            existing_text = re.sub(
+                f'output "{output_name}".*?}}', '', existing_text, flags=re.DOTALL
+            )
+
+        # Combine all new output blocks and updates to add
+        final_output = "\n\n".join(lines_to_add + updated_lines)
+
+        # Append new or updated blocks
+        with open(outputs_tf_path, "w") as f:
+            f.write(existing_text.strip() + "\n\n" + final_output + "\n")
+
+        logger.debug(f"✅ Added/updated outputs for module '{module_name}'")
+    else:
+        logger.debug(f"⚠️ No new outputs to add or update in {outputs_tf_path}.")

cluster_builder-0.3.1.dist-info/METADATA

@@ -0,0 +1,321 @@
+Metadata-Version: 2.4
+Name: cluster-builder
+Version: 0.3.1
+Summary: Swarmchestrate cluster builder
+Author-email: Gunjan <G.Kotak@westminster.ac.uk>, Jay <J.Deslauriers@westminster.ac.uk>
+License: Apache2
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: names_generator==0.2.0
+Requires-Dist: python-hcl2==7.2
+Requires-Dist: lark-parser==0.12.0
+Requires-Dist: python-dotenv==1.1.1
+Requires-Dist: psycopg2-binary==2.9.10
+Requires-Dist: yaspin==3.1.0
+Dynamic: license-file
+
+# Swarmchestrate - Cluster Builder
+
+This repository contains the codebase for **[cluster-builder]**, which builds K3s clusters for Swarmchestrate using OpenTofu.  
+
+Key features:
+- **Create**: Provisions infrastructure using OpenTofu and installs K3s.
+- **Add**: Add worker or HA nodes to existing clusters.
+- **Remove**: Selectively remove nodes from existing clusters.  
+- **Delete**: Destroys the provisioned infrastructure when no longer required. 
+
+---
+
+## Prerequisites
+
+Before proceeding, ensure the following prerequisites are installed:
+
+1. **Git**: For cloning the repository.
+2. **Python**: Version 3.9 or higher.
+3. **pip**: Python package manager.
+4. **OpenTofu**: Version 1.6 or higher for infrastructure provisioning.
+6. **Make**: To run the provided `Makefile`.
+7. **PostgreSQL**: For storing OpenTofu state.
+8. (Optional) **Docker**: To create a dev Postgres
+9. For detailed instructions on **edge device requirements**, refer to the [Edge Device Requirements](docs/edge-requirements.md) document.
+
+---
+
+## Getting Started
+
+### 1. Clone the Repository
+
+To get started, clone this repository:
+
+```bash
+git clone https://github.com/Swarmchestrate/cluster-builder.git
+ ```
+
+### 2. Navigate to the Project Directory
+
+```bash
+cd cluster-builder
+ ```
+
+### 3. Install Dependencies and Tools
+
+Run the Makefile to install all necessary dependencies, including OpenTofu:
+
+```bash
+ make install
+```
+
+This command will:
+- Install Python dependencies listed in requirements.txt.
+- Download and configure OpenTofu for infrastructure management.
+
+```bash
+ make db
+```
+
+This command will:
+- Spin up an empty dev Postgres DB (in Docker) for storing state
+
+in ths makefile database details are provide you update or use that ones name pg-db -e POSTGRES_USER=admin -e POSTGRES_PASSWORD=adminpass -e POSTGRES_DB=swarmchestrate
+
+For database setup as a service, refer to the [database setup as service](docs/database_setup.md) document
+
+### 4. Populate .env file with access config
+The .env file is used to store environment variables required by the application. It contains configuration details for connecting to your cloud providers, the PostgreSQL database, and any other necessary resources.
+
+#### 4.1.  Rename or copy the example file to **.env**
+
+```bash
+cp .env_example .env
+```
+
+#### 4.2. Open the **.env** file and add the necessary configuration for your cloud providers and PostgreSQL:
+
+```ini
+## PG Configuration
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=secret
+POSTGRES_HOST=db.example.com
+POSTGRES_DATABASE=terraform_state
+POSTGRES_SSLMODE=prefer
+
+## AWS Auth
+TF_VAR_aws_region=us-west-2
+TF_VAR_aws_access_key=AKIAXXXXXXXXXXXXXXXX
+TF_VAR_aws_secret_key=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+
+## OpenStack Auth - AppCreds Mode
+TF_VAR_openstack_auth_method=appcreds
+TF_VAR_openstack_auth_url=https://openstack.example.com:5000
+TF_VAR_openstack_application_credential_id=fdXXXXXXXXXXXXXXXX
+TF_VAR_openstack_application_credential_secret=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+TF_VAR_openstack_region=RegionOne
+
+## OpenStack Auth - User/Pass Mode
+# TF_VAR_openstack_auth_method=userpass
+# TF_VAR_openstack_auth_url=https://openstack.example.com:5000
+# TF_VAR_openstack_region=RegionOne
+# TF_VAR_openstack_user_name=myuser
+# TF_VAR_openstack_password=mypassword
+# TF_VAR_openstack_project_id=project-id-123
+# TF_VAR_openstack_user_domain_name=Default
+```
+
+---
+
+## Basic Usage
+
+### Initialisation
+
+```python
+from cluster_builder import Swarmchestrate
+
+# Initialise the orchestrator
+orchestrator = Swarmchestrate(
+    template_dir="/path/to/templates",
+    output_dir="/path/to/output"
+)
+```
+
+### Creating a New Cluster
+
+To create a new k3s cluster, use the **add_node** method with the **master** role:
+
+```python
+# Configuration for a new cluster
+config = {
+    "cloud": "aws",  # Can be 'aws', 'openstack', or 'edge'
+    "k3s_role": "master",  # Role can be 'master', 'worker', or 'ha'
+    "ha": False,  # Set to True for high availability (HA) deployments
+    "instance_type": "t2.small",  # AWS instance type
+    "ssh_key_name": "g",  # SSH key name for AWS or OpenStack
+    "ssh_user": "ec2-user",  # SSH user for the instance
+    "ssh_private_key_path": "/workspaces/cluster-builder/scripts/g.pem",  # Path to SSH private key
+    "ami": "ami-0c0493bbac867d427",  # AMI ID for AWS (specific to region)
+    "tcp_ports": [10020],  # Optional list of TCP ports to open
+    "udp_ports": [1003]  # Optional list of UDP ports to open
+}
+
+# Create the cluster (returns the cluster name)
+cluster_name = orchestrator.add_node(config)
+print(f"Created cluster: {cluster_name}")
+```
+
+### Adding Nodes to an Existing Cluster
+
+To add worker or high-availability nodes to an existing cluster:
+
+```python
+# Configuration for adding a worker node
+worker_config = {
+    "cloud": "aws",  # Cloud provider (can be 'aws', 'openstack', or 'edge')
+    "k3s_role": "worker",  # Role can be 'worker' or 'ha'
+    "ha": False,  # Set to True for high availability (HA) deployments
+    "instance_type": "t2.small",  # AWS instance type
+    "ssh_key_name": "g",  # SSH key name
+    "ssh_user": "ec2-user",  # SSH user for the instance
+    "ssh_private_key_path": "/workspaces/cluster-builder/scripts/g.pem",  # Path to SSH private key
+    "ami": "ami-0c0493bbac867d427",  # AMI ID for AWS
+    # Optional parameters:
+    # "master_ip": "12.13.14.15",  # IP address of the master node (required for worker/HA roles)
+    # "cluster_name": "elastic_mcnulty",  # Name of the cluster
+    # "security_group_id": "sg-xxxxxxxxxxxxxxx",  # Security group ID for AWS or OpenStack
+    # "tcp_ports": [80, 443],  # List of TCP ports to open
+    # "udp_ports": [53]  # List of UDP ports to open
+}
+
+# Add the worker node
+cluster_name = orchestrator.add_node(worker_config)
+print(f"Added worker node to cluster: {cluster_name}")
+```
+
+### Removing a Specific Node
+
+To remove a specific node from a cluster:
+
+```python
+# Remove a node by its resource name
+orchestrator.remove_node(
+    cluster_name="your-cluster-name",
+    resource_name="aws_eloquent_feynman"  # The resource identifier of the node
+)
+```
+
+The **remove_node** method:
+1. Destroys the node's infrastructure resources
+2. Removes the node's configuration from the cluster
+
+---
+
+### Destroying an Entire Cluster
+
+To completely destroy a cluster and all its nodes:
+
+```python
+# Destroy the entire cluster
+orchestrator.destroy(
+    cluster_name="your-cluster-name"
+)
+```
+
+The **destroy** method:
+1. Destroys all infrastructure resources associated with the cluster
+2. Removes the cluster directory and configuration files
+
+Note for **Edge Devices**:
+Since the edge device is already provisioned, the `destroy` method will not remove K3s directly from the edge device. You will need to manually uninstall K3s from your edge device after the cluster is destroyed.
+
+---
+
+### Important Configuration Requirements
+#### High Availability Flag (ha):
+
+- For k3s_role="worker" or k3s_role="ha", you must specify a master_ip (the IP address of the master node).
+
+- For k3s_role="master", you must not specify a master_ip.
+
+- The ha flag should be set to True for high availability deployment (usually when adding a ha or worker node to an existing master).
+
+#### SSH Credentials:
+
+- For all roles (k3s_role="master", k3s_role="worker", k3s_role="ha"), you must specify both ssh_user and ssh_private_key_path except for edge.
+
+- The ssh_private_key_path should be the path to your SSH private key file. Ensure that the SSH key is copied to the specified path before running the script.
+
+- The ssh_key_name and the ssh_private_key_path are different—ensure that your SSH key is placed correctly at the provided ssh_private_key_path.
+
+#### Ports:
+You can specify custom ports for your nodes in the tcp_ports and udp_ports fields. However, certain ports are required for Kubernetes deployment (even if not specified explicitly):
+
+**TCP Ports:**
+
+- 2379-2380: For etcd communication
+- 6443: K3s API server
+- 10250: Kubelet metrics
+- 51820-51821: WireGuard (for encrypted networking)
+- 22: SSH access
+- 80, 443: HTTP/HTTPS access
+- 53: DNS (CoreDNS)
+- 5432: PostgreSQL access (master node)
+
+**UDP Ports:**
+
+- 8472: VXLAN for Flannel
+- 53: DNS
+
+#### OpenStack:
+When provisioning on OpenStack, you should provide the value for 'floating_ip_pool' from which floating IPs can be allocated for the instance. If not specified, OpenTofu will not assign floating IP.
+
+---
+
+## Advanced Usage
+
+### Dry Run Mode
+
+All operations support a **dryrun** parameter, which validates the configuration 
+without making changes. A node created with dryrun should be removed with dryrun.
+
+```python
+# Validate configuration without deploying
+orchestrator.add_node(config, dryrun=True)
+
+# Validate removal without destroying
+orchestrator.remove_node(cluster_name, resource_name, dryrun=True)
+
+# Validate destruction without destroying
+orchestrator.destroy(cluster_name, dryrun=True)
+```
+
+### Custom Cluster Names
+
+By default, cluster names are generated automatically. To specify a custom name:
+
+```python
+config = {
+    "cloud": "aws",
+    "k3s_role": "master",
+    "cluster_name": "production-cluster",
+    # ... other configuration ...
+}
+
+orchestrator.add_node(config)
+```
+
+---
+
+## Template Structure
+
+Templates should be organised as follows:
+- `templates/` - Base directory for templates
+- `templates/{cloud}/` - Terraform modules for each cloud provider
+- `templates/{role}_user_data.sh.tpl` - Node initialisation scripts
+- `templates/{cloud}_provider.tf.j2` - Provider configuration templates
+
+---
+
+## DEMO
+Some test scripts have been created for demonstrating the functionality of the cluster builder. These scripts can be referred to for understanding how the system works and for testing various configurations.
+
+For detailed service deployment examples and to explore the test scripts, refer to the [test scripts](docs/test-scripts.md) document
+
+---

cluster_builder-0.3.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+cluster_builder/__init__.py,sha256=p2Rb2BTVm-ScqCKE38436WsItY1BjVAnvx7zwmneSLs,256
+cluster_builder/swarmchestrate.py,sha256=jopT6PVt4bpv2nBqiKp6Fszv2W7gkeNcL0IQfSunnEI,23141
+cluster_builder/config/__init__.py,sha256=HqCua7nqa0m4RNrH-wAw-GNZ8PfmKOeYs2Ur81xGIKU,222
+cluster_builder/config/cluster.py,sha256=igIj7HJNThaUvefwaKqes4-tRq0iCPh4T5tZFEWlgEw,4945
+cluster_builder/config/postgres.py,sha256=nQ5QxxI00GmGAbDl_9I1uEU2eBy1D2eJWGzhsBYUFMc,3354
+cluster_builder/infrastructure/__init__.py,sha256=e8XY3K7Y6FJS-ODr5ufB_myV7btFvYHnwA9sxkob8o8,247
+cluster_builder/infrastructure/executor.py,sha256=oymr_ZP8xAOcNDAuGCp1v4F81-chR3VRotoD732l4q0,2874
+cluster_builder/infrastructure/templates.py,sha256=TAdNP-012L76dOYsd7JVIQOD4K9XNobK9QWfOoYrbeU,4084
+cluster_builder/templates/aws_provider.tf,sha256=VIRuH_-8pYtJ0Mkck38WUSszHiN3DesFOWkx75aoOIY,425
+cluster_builder/templates/copy_manifest.tf,sha256=APVAN-xrgDcavzApwl3ZNiXAOx5V3B1EDYp1zHZ3BqM,865
+cluster_builder/templates/ha_user_data.sh.tpl,sha256=NJOH_yelvK5RW4aMKwIEKTBhnXHaxcxHzDUEq0lzSqE,977
+cluster_builder/templates/master_user_data.sh.tpl,sha256=b7xo2weZfdAubaEO2L7NeVtFkZoSCT6_l15UG1AVEkc,1473
+cluster_builder/templates/openstack_provider.tf,sha256=wFUmkws5xSTOM1GW0Jd8JD__VAUBPNF4j1amo2SRyVM,2049
+cluster_builder/templates/worker_user_data.sh.tpl,sha256=9Sp-rwLJvsjOopb85vumBCcMJfHFG7BNCWkUu6qUAeA,1030
+cluster_builder/templates/aws/main.tf,sha256=UXH_mEldtVI-bHBGlc6q7wG5BKiYyLsSzpSpbocqysk,4907
+cluster_builder/templates/edge/main.tf,sha256=y2X61imI-i97Cqz9FmPR-qNwGgQo2i7Aks7l2Tidq6E,2329
+cluster_builder/templates/openstack/main.tf,sha256=fw7i3NJQn752Pct5wYtijhKI2A2cLK5h0FkRkyeVmXY,7331
+cluster_builder/utils/__init__.py,sha256=TeronqOND-SIfi0e76lwD1HfUiPO2h2ZfYhLIwZ3Aks,145
+cluster_builder/utils/hcl.py,sha256=VptRAt2Cy0AxowqMJBZ60KGe4Uptji3Y9WiYrDQsrqY,11534
+cluster_builder/utils/logging.py,sha256=rwDViuqG8PMcXJWHOdtdgbGhWMnbSZ4MwfKsXHxu2B4,1242
+cluster_builder-0.3.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cluster_builder-0.3.1.dist-info/METADATA,sha256=62YtIg8aex7OFATqAeDE9OldH2B29tOJgYAGCuKjQOM,10350
+cluster_builder-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cluster_builder-0.3.1.dist-info/top_level.txt,sha256=fTW8EW1mcWoeWprjwxSHRWpqfXYX8iN-ByEt8HPXIcs,16
+cluster_builder-0.3.1.dist-info/RECORD,,

{cluster_builder-0.2.1.dist-info → cluster_builder-0.3.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any