service-client-utils 0.1.0__tar.gz

service_client_utils-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: service_client_utils
+Version: 0.1.0
+Requires-Dist: networkx
+Requires-Dist: pandas
+Requires-Dist: grpcio

service_client_utils-0.1.0/README.md

@@ -0,0 +1,66 @@
+# Client Scripts
+
+This directory contains the client-scripts, which include utility modules and sample Jupyter notebooks for interacting with different simulation backends.
+
+## Directory Structure
+
+- **notebooks/**
+  Contains sample notebooks for all supported backends. The notebooks are present in the notebooks folder and are as follows:
+
+    | Notebook Path                          | Description |
+    |----------------------------------------|-------------|
+    | analytical_congestion_aware_sample.ipynb | Simulation using analytical congestion-aware backend |
+    | analytical_congestion_unaware_sample.ipynb | Simulation using analytical congestion-unaware backend |
+    | config_to_schema_sample.ipynb          | Config files to Astra-sim schema conversion |
+    | htsim_sample.ipynb                     | htsim backend simulation |
+    | load_existing_et_example.ipynb         | Loads execution trace for ns-3 simulation |
+    | ns3_sample.ipynb                       | ns-3 backend simulation |
+
+- **notebooks/infragraph/**
+  Contains the Infragraph notebook for the NS3 backend.
+  Users can build fabrics using Infragraph and execute corresponding NS3 simulations.
+    | Notebook Path                                | Description |
+    |----------------------------------------------|-------------|
+    | infragraph/htsim_clos_fabric_2tier.ipynb     | htsim simulation: 2-tier Clos fabric |
+    | infragraph/htsim_clos_fabric_3tier.ipynb     | htsim simulation: 3-tier Clos fabric |
+    | infragraph/ns3_clos_fabric_2tier.ipynb       | ns-3 simulation: 2-tier Clos fabric |
+    | infragraph/ns3_clos_fabric_3tier.ipynb       | ns-3 simulation: 3-tier Clos fabric |
+    | infragraph/ns3_infragraph_sample_dgx_device.ipynb | ns-3 simulation: single-tier fabric with DGX devices |
+    | infragraph/ns3_infragraph_sample_generic_devices.ipynb | ns-3 simulation: single-tier fabric with generic devices |
+
+## Notebook Sections
+
+Each notebook follows a structured workflow, divided into these main sections:
+
+1. **Importing the utilities**
+   Load the helper modules required for client-side interactions.
+
+2. **Creating the AstraSim object**
+   The user initializes an AstraSim object by connecting to the service using its IP address and port number and assigning a tag for identification.
+
+3. **Creating configurations with the SDK**
+   The AstraSim object contains a configuration object that allows defining both the AstraSim and Infragraph configurations.
+   Users can either upload their existing execution traces or generate workloads by specifying:
+   - The target collective operation
+   - The data size
+   - The NPU range `[0, n]`
+    The repo uses mlcommons chakra to create execution trace for the specified npu range
+
+
+   This enables flexible workload generation tailored to various simulation setups.
+
+4. **Running the simulation**
+   The simulation is triggered using a single function that abstracts multiple backend API calls.
+   This operation handles the following automatically:
+   - Uploading the workload
+   - Setting the configuration
+   - Running the simulation
+   - Polling the simulation status
+
+   Once the status is marked as completed, the tool downloads the generated result files.
+   At present, a basic NS3 translator is available for interpreting these output files.
+
+## Notes on Tags
+
+Tags are identifiers used to distinguish simulation runs or client instances.
+They help organize configurations and manage simulation results efficiently.

service_client_utils-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "service_client_utils"
+version = "0.1.0"
+dependencies = [
+    "networkx",
+    "pandas",
+    "grpcio",
+]
+
+[tool.setuptools]
+packages = ["service_client_utils",]
+
+[tool.setuptools.package-dir]
+service_client_utils = "service_client_utils"

service_client_utils-0.1.0/service_client_utils/astra_sim.py

@@ -0,0 +1,241 @@
+"""
+MIT License
+
+Copyright (c) 2025 Keysight Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import os
+import time
+import grpc
+from enum import Enum
+import pandas as pd
+
+from chakra.schema.protobuf.et_def_pb2 import (
+    Node as ChakraNode,
+    BoolList,
+    GlobalMetadata,
+    AttributeProto as ChakraAttr,
+    COMM_COLL_NODE,
+    ALL_REDUCE,
+    ALL_TO_ALL,
+    BARRIER,
+    REDUCE,
+    REDUCE_SCATTER,
+    GATHER,
+)
+
+from service_client_utils.common import Utilities, FileFolderUtils, StatUtil
+
+from service_client_utils.astra_sim_client import AstraSimClient
+import astra_sim_sdk.astra_sim_sdk as astra_sim_sdk
+
+pd.options.mode.chained_assignment = None
+
+
+class Collective(Enum):
+    """
+    Enum class that holds the collective name to string name
+    """
+
+    ALLREDUCE = "allreduce"
+    ALLTOALL = "alltoall"
+    BARRIER = "barrier"
+    REDUCE = "reduce"
+    REDUCESCATTER = "reducescatter"
+    GATHER = "gather"
+
+
+class NetworkBackend(Enum):
+    """
+    Enum class that holds the network backend name to string name
+    """
+
+    ANALYTICAL_CONGESTION_AWARE = "ANALYTICAL_CONGESTION_AWARE"
+    ANALYTICAL_CONGESTION_UNAWARE = "ANALYTICAL_CONGESTION_UNAWARE"
+    NS3 = "NS3"
+    HTSIM = "HTSIM"
+
+
+class AstraSim:
+    """
+    Root class that is used to configure the server, configure astra-sim and run simulation
+    """
+
+    def __init__(
+        self,
+        server_endpoint,
+        tag="",
+        backend_name="NS3",
+    ):
+        self._server_endpoint = server_endpoint
+        self._astra_sim_client = AstraSimClient()
+        FileFolderUtils(tag)
+        self.configuration = astra_sim_sdk.Config()
+        self._backend_name = backend_name
+        self.tag = tag
+        self._validate_server_endpoint()
+
+    def _validate_server_endpoint(self):
+        """
+        Validate if a gRPC server is reachable.
+        """
+        try:
+            channel = grpc.insecure_channel(self._server_endpoint)
+            grpc.channel_ready_future(channel).result(timeout=2)
+            print(f"Successfully connected to gRPC server at {self._server_endpoint}")
+
+        except grpc.FutureTimeoutError as exc:
+            raise ConnectionError(
+                f"Could not connect to gRPC server at {self._server_endpoint}. "
+                "Ensure the server is running and reachable."
+            ) from exc
+
+    def generate_collective(self, collective, coll_size, npu_range):
+        """
+        This is a wrapper on top of generate_chakra_node to generate the collective
+        """
+        if not npu_range:
+            print("NPU range is not defined")
+            return ""
+
+        if len(npu_range) < 2:
+            print("NPU range not set correctly")
+            return ""
+
+        return WorkloadConfiguration.generate_chakra_node(
+            collective=collective, coll_size=coll_size, npu_range=npu_range, tag=self.tag
+        )
+
+    def run_simulation(self, network_backend):
+        """
+        A wrapper call over multiple operations allowing to upload, run, and download files for a simulation
+        """
+        workload_dir = self.configuration.common_config.workload
+        workload_folder = os.path.dirname(workload_dir)
+        self._astra_sim_client.set_url(self._server_endpoint)  # type: ignore
+        self._astra_sim_client.pack_zip(workload_folder)
+        self._astra_sim_client.upload_config()
+        self._astra_sim_client.set_config(self.configuration)
+        self._astra_sim_client.run_simulation(network_backend.value)
+        while True:
+            status = self._astra_sim_client.get_status()
+            if status in ["completed", "failed", "terminated"]:
+                break
+            print(f"astra-sim server Status: {status}")
+            time.sleep(2)
+        self._astra_sim_client.get_file("simulation.log")
+        if self._astra_sim_client.get_status() in ["failed", "terminated"]:
+            print("Simulation " + self._astra_sim_client.get_status())
+        else:
+            print("Downloading Output files....")
+            self._astra_sim_client.download_files()
+            print("All files downloaded Successfully")
+            if network_backend.value == "NS3":
+                print("Translating Metrics...")
+                if self._backend_name == "NS3":
+                    StatUtil.ns3_fct_csv()
+                    StatUtil.ns3_flow_statistics()
+                print("All metrics translated successfully")
+            print("Simulation completed")
+
+    def download_configuration(self):
+        """
+        Function that downloads the configuration in zip format consisting of all the files required for running the simulation.
+        """
+        try:
+            self._astra_sim_client.get_config()
+        except FileNotFoundError as e:
+            print(f"Configuration file not found: {e}")
+            raise
+        except Exception as e:
+            print(f"Failed to download configuration: {e}")
+            raise
+
+
+class WorkloadConfiguration:
+    """
+    Static class that handles the chakra workload confiuration
+    """
+
+    @staticmethod
+    def get_collectives():
+        """
+        Returns all the supported collective
+        """
+        return """
+        Supported:
+            ALL_REDUCE
+            ALL_GATHER
+            ALL_TO_ALL
+            BARRIER
+            REDUCE
+            REDUCE_SCATTER_BLOCK
+            GATHER
+        Not Supported:
+            REDUCE_SCATTER
+            BROADCAST
+            ALL_GATHER
+"""
+
+    @staticmethod
+    def generate_chakra_node(collective, npu_range, coll_size, tag):
+        """
+        This generates the chakra node for the given npu range [m - n], the collective and collective_size inside the tag directory
+        """
+        collective = collective.value
+        collective_dir = os.path.join(FileFolderUtils().CONFIG_DIR, FileFolderUtils().WORKLOAD_DIR)
+        Utilities.delete_folder(collective_dir)
+
+        os.makedirs(collective_dir)
+
+        for npu_id in range(npu_range[0], npu_range[1]):
+            output_filename = f"{collective_dir}/{tag}.{str(npu_id)}.et"
+            with open(output_filename, "wb") as et:
+                # Chakra Metadata
+                Utilities.encode_message(et, GlobalMetadata(version="0.0.4"))
+
+                # create Chakra Node
+                node = ChakraNode()
+                node.id = 1
+                node.name = collective
+                node.type = COMM_COLL_NODE
+
+                # assign attributes
+                node.attr.append(ChakraAttr(name="is_cpu_op", bool_val=False))
+                if collective == "allreduce":
+                    node.attr.append(ChakraAttr(name="comm_type", int64_val=ALL_REDUCE))
+                elif collective == "alltoall":
+                    node.attr.append(ChakraAttr(name="comm_type", int64_val=ALL_TO_ALL))
+                elif collective == "barrier":
+                    node.attr.append(ChakraAttr(name="comm_type", int64_val=BARRIER))
+                elif collective == "reduce":
+                    node.attr.append(ChakraAttr(name="comm_type", int64_val=REDUCE))
+                elif collective == "reducescatter":
+                    node.attr.append(ChakraAttr(name="comm_type", int64_val=REDUCE_SCATTER))
+                elif collective == "gather":
+                    node.attr.append(ChakraAttr(name="comm_type", int64_val=GATHER))
+                node.attr.append(ChakraAttr(name="comm_size", int64_val=coll_size))
+                node.attr.append(ChakraAttr(name="involved_dim", bool_list=BoolList(values=[True])))
+
+                # store Chakra ET file
+                Utilities.encode_message(et, node)
+        print("Generated " + str(npu_range[1] - npu_range[0]) + " et in " + collective_dir)
+        return os.path.join(collective_dir, tag)

service_client_utils-0.1.0/service_client_utils/astra_sim_client.py

@@ -0,0 +1,198 @@
+"""
+MIT License
+
+Copyright (c) 2025 Keysight Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import os
+import json
+import logging
+import threading
+
+import astra_sim_sdk.astra_sim_sdk as astra_sim
+from service_client_utils.common import Utilities, FileFolderUtils
+
+
+class AstraSimClient:
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super(AstraSimClient, cls).__new__(cls, *args, **kwargs)
+        return cls._instance
+
+    def __init__(self):
+        self._url = ""
+        self._api = astra_sim.api(
+            location="localhost:50051",
+            transport=astra_sim.Transport.GRPC,
+            logger=None,
+            loglevel=logging.ERROR,
+        )
+        self._api.enable_grpc_streaming = True  # type: ignore
+        # api.chunk_size = 1
+        self._api.request_timeout = 180  # type: ignore
+        self._stopping_event = threading.Event()
+        self._backend = None
+
+    def set_url(self, url):
+        """
+        Set the service URL
+        """
+        self._url = url
+        self._api = astra_sim.api(
+            location=url,
+            transport=astra_sim.Transport.GRPC,
+            logger=None,
+            loglevel=logging.ERROR,
+        )
+        self._api.enable_grpc_streaming = True  # type: ignore
+
+    def get_api(self):
+        """
+        Returns the grpc api
+        """
+        return self._api
+
+    def get_api_stub(self):
+        """
+        Returns the grpc api stub
+        """
+        return self.get_api()._get_stub()  # type: ignore
+
+    def upload_config(self):
+        """
+        Function that uploads config from the zip path which is inside the <tag> dir name
+        """
+        with open(FileFolderUtils().ZIP_PATH, "rb") as f:
+            file_data = f.read()
+        return self.get_api().upload_config(payload=file_data)
+
+    def set_config(self, config):
+        """
+        Function that sets the config in the service
+        """
+        response = self.get_api().set_config(payload=config)
+        print(response)
+
+    def run_simulation(self, backend):
+        """
+        Function that triggers simulation run in service directory
+        """
+        control = astra_sim.Control(choice="start")
+        if "ANALYTICAL_CONGESTION_AWARE" == backend.upper():
+            control.start.backend = astra_sim.ControlStart.ANALYTICAL_CONGESTION_AWARE
+        elif "ANALYTICAL_CONGESTION_UNAWARE" == backend.upper():
+            control.start.backend = astra_sim.ControlStart.ANALYTICAL_CONGESTION_UNAWARE
+        elif "NS3" == backend.upper():
+            control.start.backend = astra_sim.ControlStart.NS3
+        elif "HTSIM" == backend.upper():
+            control.start.backend = astra_sim.ControlStart.HTSIM
+        # control.start.action = astra_sim.ControlStart.NS3
+        response = self.get_api().set_control_action(control)
+        print(response)
+
+    def get_status(self):
+        """
+        Function to get the simulation status from service
+        """
+        response = self.get_api().get_status()
+        return response.status  # type: ignore
+
+    def get_file(self, filename):
+        """
+        Function to download the result file from service
+        """
+        result = self.get_api().result()
+        result.filename = filename
+
+        response = self.get_api().get_result(result)
+        if response is None:
+            open(os.path.join(FileFolderUtils().OUTPUT_DIR, filename), "w", encoding="utf-8").close()
+        else:
+            if response is not None:
+                bytes_data = response.read()  # type: ignore
+                # data_str = bytes_data.decode("utf-8")
+                # Step 2: Decode bytes to string
+                with open(os.path.join(FileFolderUtils().OUTPUT_DIR, filename), "wb") as f:
+                    f.write(bytes_data)
+            else:
+                raise FileNotFoundError("Unable to read file")
+
+    def get_metadata(self):
+        """
+        Function to download the result files metadata from service
+        """
+        # result = astra_sim.Result(choice="metadata")
+        result = self.get_api().result()
+        result.choice = "metadata"
+        response = self.get_api().get_result(result)
+        # Step 1: Read bytes from the stream
+        bytes_data = response.read()  # type: ignore
+        data = bytes_data.decode("utf-8")
+
+        # Step 3: Parse string to dict
+        data_dict = json.loads(data)
+        filelist = []
+        for filedata in data_dict:
+            filelist.append(filedata["filename"])
+        return filelist
+
+    def download_files(self):
+        """
+        Function to download the result files from service
+        """
+        print("Transferring Files from ASTRA-sim server")
+        metadata = self.get_metadata()
+        if len(metadata) == 0:
+            print("Result Files missing")
+            return []
+
+        # Utilities.delete_folder(FileFolderUtils().OUTPUT_DIR)
+
+        for file in metadata:
+            # download the file
+            print(f"Downloading file: {file}")
+            self.get_file(file)
+        return metadata
+
+    def pack_zip(self, workload_folder=""):
+        """
+        Function that zips all the workloads in the config dir
+        """
+        print("Generating Configuration ZIP now")
+        if workload_folder == "":
+            workload_folder = FileFolderUtils().CONFIG_DIR
+        Utilities.zip_folder(os.path.join(workload_folder, ".."), FileFolderUtils().ZIP_PATH)
+        print("pack_zip complete")
+
+    def get_config(self):
+        """
+        Function that downloads the configuration in zip format consisting of all the files required for running the simulation.
+        """
+        config_response = self.get_api().get_config()
+        if config_response is None:
+            raise FileNotFoundError("Server couldn't return config")
+        zip_bytes = config_response.read()
+        print(f"Downloaded all configuration in {FileFolderUtils().SERVER_CONFIG_ZIP}")
+        output_path = os.path.join(FileFolderUtils().OUTPUT_DIR, FileFolderUtils().SERVER_CONFIG_ZIP)
+        with open(output_path, "wb") as f:
+            f.write(zip_bytes)

service_client_utils-0.1.0/service_client_utils/common.py

@@ -0,0 +1,319 @@
+"""
+MIT License
+
+Copyright (c) 2025 Keysight Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import os
+import shutil
+import json
+import zipfile
+import struct
+import pandas as pd
+
+pd.options.mode.chained_assignment = None
+
+
+class FileFolderUtils:
+    """
+    Class that holds the file folder utilities and the paths
+    """
+
+    _instance = None
+    _initialized = False
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super(FileFolderUtils, cls).__new__(cls)
+        return cls._instance
+
+    @classmethod
+    def get_instance(cls):
+        """
+        Returns the instance of the FileFolderUtils class
+        """
+        return cls._instance
+
+    UTILS_PATH = os.path.abspath(__file__)
+    SRC_DIR = os.path.dirname(UTILS_PATH)
+    HOME_DIR = os.path.join(SRC_DIR, "..")
+
+    def __init__(self, tag=""):
+        if not self._initialized:
+            self._initialized = True
+            if tag == "":
+                tag = "new_run"
+            self.tag_name = tag
+            self.TRIAL_DIR = ""
+            self.TAG_DIR = ""
+            self.INFRA_DIR = ""
+            self.CONFIG_DIR = ""
+            self.OUTPUT_DIR = ""
+            self.ZIP_DIR = ""
+            self.ZIP_FILE_NAME = r"config.zip"
+            self.SERVER_ZIP_FILE_NAME = r"server_configuration.zip"
+            self.INFRA_JSON_FILENAME = "infra.json"
+            self.BIND_JSON_FILENAME = "bind.json"
+            self.NETWORK_CONFIGURATION_FILENAME = "network_config.txt"
+            self.NS3_TOPOLOGY_FILENAME = "nc-topology-file.txt"
+            self.REMOTE_MEMORY_FILENAME = "RemoteMemory.json"
+            self.SYSTEM_CONFIGURATION_FILENAME = "system.json"
+            self.LOGICAL_TOPOLOGY_FILENAME = "logical.json"
+            self.ZIP_PATH = ""
+            self.WORKLOAD_DIR = "workload"
+            self.set_tag(tag)
+
+    def set_tag(self, tag):
+        """
+        Sets the tag - creates the folders and subfolders with the tag name to provide unique testing configurations and results
+        """
+        self.tag_name = tag
+        self.TRIAL_DIR = os.path.join(FileFolderUtils.HOME_DIR, "trial")
+        self.TAG_DIR = os.path.join(self.TRIAL_DIR, self.tag_name)
+        self.INFRA_DIR = os.path.join(self.TAG_DIR, "infrastructure")
+        self.CONFIG_DIR = os.path.join(self.TAG_DIR, "configuration")
+        self.OUTPUT_DIR = os.path.join(self.TAG_DIR, "output")
+        self.ZIP_DIR = os.path.join(self.TAG_DIR, "zip_dir")
+        self.ZIP_PATH = os.path.join(self.TAG_DIR, self.ZIP_FILE_NAME)
+        self.SERVER_CONFIG_ZIP = os.path.join(self.TAG_DIR, self.SERVER_ZIP_FILE_NAME)
+        self.reset_directories()
+
+    def reset_directories(self):
+        """
+        Resets the directories: INFRA_DIR, CONFIG_DIR, OUTPUT_DIR, ZIP_DIR
+        """
+        print("Resetting test directory")
+        Utilities.delete_folder(self.TAG_DIR)
+        Utilities.delete_folder(self.INFRA_DIR)
+        Utilities.delete_folder(self.CONFIG_DIR)
+        Utilities.delete_folder(self.OUTPUT_DIR)
+        Utilities.delete_folder(self.ZIP_DIR)
+
+        Utilities.create_folder(self.TAG_DIR)
+        Utilities.create_folder(self.INFRA_DIR)
+        Utilities.create_folder(self.CONFIG_DIR)
+        Utilities.create_folder(self.OUTPUT_DIR)
+        Utilities.create_folder(self.ZIP_DIR)
+
+
+class Utilities:
+    """
+    Utilities class that has multiple static function calls like zip_folder, delete_folder, create_folder and so on
+    """
+
+    @staticmethod
+    def zip_folder(folder_path: str, output_path: str):
+        """
+        Function that zip a given folder - files and subdirectories inside it and dumps to an output path
+        Note that the output path is a full path of the zip file and the directories mentioned in the path should exist
+        """
+        print("output_path: " + output_path)
+        print("folder_path: " + folder_path)
+        with zipfile.ZipFile(output_path, "w", zipfile.ZIP_DEFLATED) as zipf:
+            for root, _, files in os.walk(folder_path):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, folder_path)
+                    zipf.write(file_path, arcname)
+
+    @staticmethod
+    def delete_folder(folder):
+        """
+        Function that deletes a folder and its contents
+        """
+        if not os.path.exists(folder):
+            # print(f"The folder {folder} does not exist.")
+            return
+
+        for filename in os.listdir(folder):
+            file_path = os.path.join(folder, filename)
+
+            try:
+                if os.path.isfile(file_path) or os.path.islink(file_path):
+                    os.unlink(file_path)
+                elif os.path.isdir(file_path):
+                    shutil.rmtree(file_path)
+            except Exception as e:
+                print(f"Failed to delete {file_path}. Reason: {e}")
+
+        os.rmdir(folder)
+        print("All contents of the folder " + folder + " have been deleted.")
+
+    @staticmethod
+    def create_folder(folder: str):
+        """
+        Function that creates a folder from the parameter: folder
+        """
+        try:
+            if not os.path.exists(folder):
+                os.makedirs(folder)
+                # print(f"Folder created at: {folder}")
+            else:
+                print(f"Folder already exists at: {folder}")
+        except Exception as e:
+            print(f"An error occurred: {e}")
+
+    @staticmethod
+    def encode_variant_32(out_file, value):
+        """
+        The encoding of the Varint32 is copied from
+        google.protobuf.internal.encoder and is only repeated here to
+        avoid depending on the internal functions in the library.
+        """
+        bits = value & 0x7F
+        value >>= 7
+        while value:
+            out_file.write(struct.pack("<B", 0x80 | bits))
+            bits = value & 0x7F
+            value >>= 7
+        out_file.write(struct.pack("<B", bits))
+
+    @staticmethod
+    def encode_message(out_file, message):
+        """
+        Encoded a message with the length prepended as a 32-bit varint.
+        """
+        out = message.SerializeToString()
+        Utilities.encode_variant_32(out_file, len(out))
+        out_file.write(out)
+
+    @staticmethod
+    def serialize_ns3_configuration_to_dict(file_path: str) -> dict:
+        """
+        Function that parses the ns3 network file and returns a dictionary
+        """
+        config = {}
+        special_keys = {"KMAX_MAP", "KMIN_MAP", "PMAX_MAP"}
+        with open(file_path, "r", encoding="utf-8") as network_file:
+            for line in network_file:
+                line_parts = line.strip().split()
+                if not line_parts:
+                    continue
+                key, values = line_parts[0], line_parts[1:]
+                if key in special_keys:
+                    config[key] = " ".join(values)
+                else:
+                    if len(values) == 1:
+                        config[key] = values[0]
+                    else:
+                        config[key] = values
+        return config
+
+    @staticmethod
+    def to_dict(obj):
+        """Safe conversion: works whether serialize() returns str or dict."""
+        serialized = obj.serialize()
+        return json.loads(serialized) if isinstance(serialized, str) else serialized
+
+
+class StatUtil:
+    """
+    Class that holds the utilities for statistics
+    """
+
+    @staticmethod
+    def ns3_flow_statistics():
+        """
+        This generates ns3 flow statistics by reading fct.txt
+        """
+        df = pd.read_csv(
+            os.path.join(FileFolderUtils().OUTPUT_DIR, "fct.txt"),
+            delim_whitespace=True,
+            header=None,
+        )
+
+        df.columns = [
+            "Source ip",
+            "Destination ip",
+            "Source Port",
+            "Destination Port",
+            "Data size (B)",
+            "Start Time",
+            "FCT",
+            "Standalone FCT",
+        ]
+        df["Source ip"] = df["Source ip"].apply(StatUtil.hex_to_ip)
+        df["Destination ip"] = df["Destination ip"].apply(StatUtil.hex_to_ip)
+        df["Total Bytes Tx"] = df["Data size (B)"]
+        df["Total Bytes Rx"] = df["Total Bytes Tx"]
+        df["Completion time (ms)"] = df["FCT"] / 1000000
+        df["Start (ms)"] = df["Start Time"] / 1000000
+        df["End (ms)"] = df["Start (ms)"] + df["Completion time (ms)"]
+        df["FCT"] = df["FCT"].astype(int)
+
+        df.to_csv(os.path.join(FileFolderUtils().OUTPUT_DIR, "flow_stats.csv"), index=False)
+        print(
+            "Generated: flow_stats.csv at: ",
+            os.path.join(FileFolderUtils().OUTPUT_DIR, "flow_stats.csv"),
+        )
+        return df
+
+    @staticmethod
+    def ns3_fct_csv():
+        """
+        This generates ns3 fct statistics by reading fct.txt - creates a dataframe from the txt file
+        """
+        df = pd.read_csv(
+            os.path.join(FileFolderUtils().OUTPUT_DIR, "fct.txt"),
+            delim_whitespace=True,
+            header=None,
+        )
+        df.columns = [
+            "Source Hex ip",
+            "Destination Hex ip",
+            "Source Port",
+            "Destination Port",
+            "Data size (B)",
+            "Start Time",
+            "FCT",
+            "Standalone FCT",
+        ]
+
+        df.to_csv(os.path.join(FileFolderUtils().OUTPUT_DIR, "fct.csv"), index=False)
+        print("Generated fct.csv at: ", os.path.join(FileFolderUtils().OUTPUT_DIR, "fct.csv"))
+        return df
+
+    @staticmethod
+    def hex_to_ip(hex_str):
+        """
+        static method that converts a hex string to an IP Address
+        """
+        try:
+            hex_str = hex_str.replace("a", "A")
+            hex_str = hex_str.replace("b", "B")
+            hex_str = hex_str.replace("c", "C")
+            hex_str = hex_str.replace("d", "D")
+            hex_str = hex_str.replace("e", "E")
+            hex_str = hex_str.replace("f", "F")
+            # Ensure it's exactly 6 hex digits
+
+            # Convert to integer
+            num = int(hex_str, 16)
+
+            octet1 = (num >> 24) & 0xFF
+            octet2 = (num >> 16) & 0xFF
+            octet3 = (num >> 8) & 0xFF
+            octet4 = num & 0xFF
+
+            # Format as IPv4 address
+            return f"{octet1}.{octet2}.{octet3}.{octet4}"
+        except ValueError:
+            return "Invalid Hex"

service_client_utils-0.1.0/service_client_utils/config_to_schema.py

@@ -0,0 +1,411 @@
+"""
+MIT License
+
+Copyright (c) 2025 Keysight Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import json
+import yaml
+import toml
+import traceback
+import astra_sim_sdk.astra_sim_sdk as astra_sim
+
+try:
+    from common import Utilities
+except:
+    from .common import Utilities
+
+
+class TranslateConfig:
+    """
+    Class that holds translators that convert a file configuration to an astra-sim object config
+    """
+
+    @staticmethod
+    def translate_remote_memory(remote_memory_file_path: str, configuration: astra_sim.Config):
+        """
+        This translates the remote memory file to astra-sim config
+        The main inputs are the:
+            - remote_memory_file_path - full file path of the remote memory configuration
+            - configuration - which is astra-sim config
+        The file values are set in the configuration object at: configuration.common_config.remote_memory
+        """
+        try:
+            with open(remote_memory_file_path, "r", encoding="utf-8") as rm_file:
+                rm = json.load(rm_file)
+            new_conf = {}
+            for key in rm:
+                new_conf[key.replace("-", "_")] = rm[key]
+            configuration.common_config.remote_memory.deserialize(new_conf)
+        except Exception as e:
+            print(f"Error translating remote memory configuration from file '{remote_memory_file_path}': {e}")
+            traceback.print_exc()
+            raise RuntimeError("Failed to translate remote memory file configuration.") from e
+
+    @staticmethod
+    def translate_system_configuration(system_config_file_path: str, configuration: astra_sim.Config):
+        """
+        This translates the system file to astra-sim config
+        The main inputs are the:
+            - system_config_file_path - full file location of system configuration
+            - configuration - which is astra-sim config
+        The file values are set in the configuration object at: configuration.common_config.system
+        """
+        try:
+            with open(system_config_file_path, "r", encoding="utf-8") as sc_file:
+                sc = json.load(sc_file)
+            new_conf = {}
+            for key in sc:
+                new_conf[key.replace("-", "_")] = sc[key]
+            if "L" in new_conf:
+                new_conf["latency"] = new_conf["L"]
+                del new_conf["L"]
+            if "o" in new_conf:
+                new_conf["overhead"] = new_conf["o"]
+                del new_conf["o"]
+
+            if "g" in new_conf:
+                new_conf["gap"] = new_conf["g"]
+                del new_conf["g"]
+
+            if "G" in new_conf:
+                new_conf["global_memory"] = new_conf["G"]
+                del new_conf["G"]
+
+            configuration.common_config.system.deserialize(new_conf)
+        except Exception as e:
+            print(f"Error translating system config configuration from file '{system_config_file_path}': {e}")
+            traceback.print_exc()
+            raise RuntimeError("Failed to translate system config file configuration.") from e
+
+    @staticmethod
+    def translate_communicator_configuration(
+        communicator_config_file_path: str, configuration: astra_sim.Config
+    ):
+        """
+        This translates the communicator group file to astra-sim config
+        The main inputs are the:
+            - communicator_config_file_path - full file path of communicator group configuration
+            - configuration - which is astra-sim config
+        The file values are set in the configuration object at: configuration.common_config.communicator_group
+        """
+        try:
+            with open(communicator_config_file_path, "r", encoding="utf-8") as cg_file:
+                cg = json.load(cg_file)
+            for key, value in cg.items():
+                configuration.common_config.communicator_group.add(key, value)
+        except Exception as e:
+            print(
+                f"Error translating communicator configuration from file '{communicator_config_file_path}': {e}"
+            )
+            traceback.print_exc()
+            raise RuntimeError("Failed to translate communicator file configuration.") from e
+
+    @staticmethod
+    def translate_ns3_nc_topology_configuration(
+        nc_topology_config_file_path: str, configuration: astra_sim.Config
+    ):
+        """
+        This translates the ns3 nc topology file to astra-sim config
+        The main inputs are the:
+            - nc_topology_config_file_path - full file path of ns3 nc topoology txt
+            - configuration - which is astra-sim config
+        The file values are set in the configuration object at: configuration.network_backend.ns3.topology.nc_topology
+        """
+        try:
+            with open(nc_topology_config_file_path, "r", encoding="utf-8") as nc_topo_file:
+                config_topo = configuration.network_backend.ns3.topology.nc_topology
+                for line_number, line in enumerate(nc_topo_file):
+                    line_list = line.strip().split()
+                    if not line_list:
+                        continue  # incase if there are no switches
+                    if line_number == 0:
+                        total_nodes, total_switches, total_links = line_list[0], line_list[1], line_list[2]
+                        config_topo.total_nodes = int(total_nodes)
+                        config_topo.total_switches = int(total_switches)
+                        config_topo.total_links = int(total_links)
+                    elif line_number == 1:
+                        switch_list = [int(x) for x in line_list]
+                        config_topo.switch_ids = switch_list
+
+                    else:
+                        src_index, dest_index, bandwidth, latency, error_rate = (
+                            line_list[0],
+                            line_list[1],
+                            line_list[2],
+                            line_list[3],
+                            line_list[4],
+                        )
+                        config_topo.connections.add(
+                            int(src_index), int(dest_index), bandwidth, latency, error_rate
+                        )
+        except Exception as e:
+            print(
+                f"Error translating nc topology configuration from file '{nc_topology_config_file_path}': {e}"
+            )
+            traceback.print_exc()
+            raise RuntimeError("Failed to translate nc topology file configuration.") from e
+
+    @staticmethod
+    def translate_ns3_network_configuration(network_config_file_path: str, configuration: astra_sim.Config):
+        """
+        This translates the ns3 network file to astra-sim config
+        The main inputs are the:
+            - nc_topology_config_file_path - full file path of ns3 network configuration
+            - configuration - which is astra-sim config
+        The file values are set in the configuration object at: onfiguration.network_backend.ns3.network
+        """
+        try:
+            network_dict = Utilities.serialize_ns3_configuration_to_dict(network_config_file_path)
+            config_network = configuration.network_backend.ns3.network
+            config_network.enable_qcn = int(network_dict["ENABLE_QCN"])
+            config_network.use_dynamic_pfc_threshold = int(network_dict["USE_DYNAMIC_PFC_THRESHOLD"])
+            config_network.packet_payload_size = int(network_dict["PACKET_PAYLOAD_SIZE"])
+            config_network.topology_file = network_dict["TOPOLOGY_FILE"]
+            config_network.flow_file = network_dict["FLOW_FILE"]
+            config_network.trace_file = network_dict["TRACE_FILE"]
+            config_network.trace_output_file = network_dict["TRACE_OUTPUT_FILE"]
+            config_network.fct_output_file = network_dict["FCT_OUTPUT_FILE"]
+            config_network.pfc_output_file = network_dict["PFC_OUTPUT_FILE"]
+            config_network.qlen_mon_file = network_dict["QLEN_MON_FILE"]
+            config_network.qlen_mon_start = int(network_dict["QLEN_MON_START"])
+            config_network.qlen_mon_end = int(network_dict["QLEN_MON_END"])
+            config_network.simulator_stop_time = float(network_dict["SIMULATOR_STOP_TIME"])
+            config_network.cc_mode = int(network_dict["CC_MODE"])
+            config_network.alpha_resume_interval = int(network_dict["ALPHA_RESUME_INTERVAL"])
+            config_network.rate_decrease_interval = int(network_dict["RATE_DECREASE_INTERVAL"])
+            config_network.clamp_target_rate = int(network_dict["CLAMP_TARGET_RATE"])
+            config_network.rp_timer = int(network_dict["RP_TIMER"])
+            config_network.ewma_gain = float(network_dict["EWMA_GAIN"])
+            config_network.fast_recovery_times = int(network_dict["FAST_RECOVERY_TIMES"])
+            config_network.rate_ai = network_dict["RATE_AI"]
+            config_network.rate_hai = network_dict["RATE_HAI"]
+            config_network.min_rate = network_dict["MIN_RATE"]
+            config_network.dctcp_rate_ai = network_dict["DCTCP_RATE_AI"]
+            config_network.error_rate_per_link = float(network_dict["ERROR_RATE_PER_LINK"])
+            config_network.l2_chunk_size = int(network_dict["L2_CHUNK_SIZE"])
+            config_network.l2_ack_interval = int(network_dict["L2_ACK_INTERVAL"])
+            config_network.l2_back_to_zero = int(network_dict["L2_BACK_TO_ZERO"])
+            config_network.has_win = int(network_dict["HAS_WIN"])
+            config_network.global_t = int(network_dict["GLOBAL_T"])
+            config_network.var_win = int(network_dict["VAR_WIN"])
+            config_network.fast_react = int(network_dict["FAST_REACT"])
+            config_network.u_target = float(network_dict["U_TARGET"])
+            config_network.mi_thresh = int(network_dict["MI_THRESH"])
+            config_network.int_multi = int(network_dict["INT_MULTI"])
+            config_network.multi_rate = int(network_dict["MULTI_RATE"])
+            config_network.sample_feedback = int(network_dict["SAMPLE_FEEDBACK"])
+            config_network.pint_log_base = float(network_dict["PINT_LOG_BASE"])
+            config_network.pint_prob = float(network_dict["PINT_PROB"])
+            config_network.rate_bound = int(network_dict["RATE_BOUND"])
+            config_network.ack_high_prio = int(network_dict["ACK_HIGH_PRIO"])
+            config_network.link_down = [int(x) for x in network_dict["LINK_DOWN"]]
+            config_network.enable_trace = int(network_dict["ENABLE_TRACE"])
+            config_network.kmax_map = network_dict["KMAX_MAP"]
+            config_network.kmin_map = network_dict["KMIN_MAP"]
+            config_network.pmax_map = network_dict["PMAX_MAP"]
+            config_network.buffer_size = int(network_dict["BUFFER_SIZE"])
+            config_network.nic_total_pause_time = int(network_dict["NIC_TOTAL_PAUSE_TIME"])
+        except Exception as e:
+            print(
+                f"Error translating ns3 network file configuration from file '{network_config_file_path}': {e}"
+            )
+            traceback.print_exc()
+            raise RuntimeError("Failed to translate ns3 network file configuration.") from e
+
+    @staticmethod
+    def translate_ns3_logical_configuration(logical_config_file_path: str, configuration: astra_sim.Config):
+        """
+        This translates the ns3 logical configuration file to astra-sim config
+        The main inputs are the:
+            - nc_topology_config_file_path - full file path of ns3 network configuration
+            - configuration - which is astra-sim config
+        The file values are set in the configuration object at: configuration.network_backend.ns3.logical_topology.logical_dimensions
+        """
+        try:
+            with open(logical_config_file_path, "r", encoding="utf-8") as lc_file:
+                lc = json.load(lc_file)
+            new_conf = {}
+            logical_dims_value = lc.get("logical-dims")
+            if not logical_dims_value:
+                raise ValueError("no value for logical_dims")
+            else:
+                new_conf["logical_dims"] = logical_dims_value
+
+            configuration.network_backend.ns3.logical_topology.deserialize(new_conf)
+
+            configuration.network_backend.ns3.logical_topology.logical_dimensions = new_conf["logical_dims"]
+        except Exception as e:
+            print(f"Error translating ns3 logical configuration from file '{logical_config_file_path}': {e}")
+            traceback.print_exc()
+            raise RuntimeError("Failed to translate ns3 logical configuration.") from e
+
+    @staticmethod
+    def translate_analytical_network(
+        network_config_file_path: str, configuration: astra_sim.Config, backend_name: str
+    ):
+        """
+        This translates the analytical network configuration file to astra-sim config
+        The main inputs are the:
+            - network_config_file_path - full file path of analytical network configuration
+            - configuration - which is astra-sim config
+        The file values are set in the configuration object
+        """
+        try:
+            backend_list = ["analytical_congestion_aware", "analytical_congestion_unaware", "htsim"]
+            if backend_name in backend_list:
+                config_network = getattr(configuration.network_backend, backend_name)
+                config_topo = config_network.topology.network
+                with open(network_config_file_path, "r", encoding="utf-8") as network_file:
+                    network_yaml = yaml.safe_load(network_file)
+                number_of_dim = len(network_yaml["topology"])
+                for i in range(number_of_dim):
+                    topo_value = network_yaml["topology"][i].lower()
+                    npu_count = network_yaml["npus_count"][i]
+                    bandwidth = network_yaml["bandwidth"][i]
+                    latency = network_yaml["latency"][i]
+                    config_topo.add(topo_value, npu_count, bandwidth, latency)
+            else:
+                return f"please select backend_name from {backend_list}"
+        except Exception as e:
+            print(
+                f"Error translating analytical network configuration from file '{network_config_file_path}': {e}"
+            )
+            traceback.print_exc()
+            raise RuntimeError("Failed to translate analytical network configuration.") from e
+
+    @staticmethod
+    def translate_htsim_fat_tree_topology(htsim_fat_tree_path: str, configuration: astra_sim.Config):
+        """
+        This translates the htsim network fat tree topology configuration file to astra-sim config
+        The main inputs are the:
+            - htsim_fat_tree_path - full file path of htsim fat tree
+            - configuration - which is astra-sim config
+        The file values are set in the configuration object: configuration.network_backend.htsim.topology.network_topology_configuration.htsim_topology.fat_tree
+        """
+        try:
+            topo_dict = TranslateConfig._parse_htsim_topo(htsim_fat_tree_path)
+            config_network_topo = (
+                configuration.network_backend.htsim.topology.network_topology_configuration.htsim_topology.fat_tree
+            )
+            config_network_topo.nodes = topo_dict["Nodes"]
+            config_network_topo.tiers = topo_dict["Tiers"]
+            config_network_topo.podsize = topo_dict["Podsize"]
+
+            for key, value in topo_dict.items():
+                if not key.startswith("tier_"):
+                    continue  # skip non-tier keys
+
+                tier_obj = getattr(config_network_topo, key)
+                mapping = {
+                    "Downlink_speed_Gbps": "downlink_speed_gbps",
+                    "Downlink_Latency_ns": "downlink_latency_ns",
+                    "Radix_Down": "radix_down",
+                    "Radix_Up": "radix_up",
+                    "Bundle": "bundle",
+                }
+
+                for k, attr in mapping.items():
+                    if k in value:
+                        setattr(tier_obj, attr, value[k])
+        except Exception as e:
+            print(f"Error translating htsim fat tree configuration from file '{htsim_fat_tree_path}': {e}")
+            traceback.print_exc()
+            raise RuntimeError("Failed to translate htsim fat tree network configuration.") from e
+
+    @staticmethod
+    def translate_ns3_trace_file_to_schema(ns3_trace_file_path: str, configuration: astra_sim.Config):
+        """
+        This translates the ns3 trace file to astra-sim config
+        The main inputs are the:
+            - ns3_trace_file_path - full file path of ns3 trace txt
+            - configuration - which is astra-sim config
+        The file values are set in the configuration object at: configuration.network_backend.ns3.trace.trace_ids
+        """
+        try:
+            trace_list = []
+            with open(ns3_trace_file_path, "r", encoding="utf-8") as trace_file:
+                next(trace_file)  # skip the first line, that is the number of npus
+                trace_list = list(map(int, trace_file.readline().split()))
+            configuration.network_backend.ns3.trace.trace_ids = trace_list
+        except Exception as e:
+            print(f"Error translating ns3 trace file configuration from file '{ns3_trace_file_path}': {e}")
+            traceback.print_exc()
+            raise RuntimeError("Failed to translate ns3 trace file configuration.") from e
+
+    @staticmethod
+    def translate_logging_file_to_schema(logging_file_path: str, configruation: astra_sim.Config):
+        """
+        This translates the logging configuration to astra-sim config
+        The main inputs are the:
+            - logging_file_path - full file path of logging toml file
+            - configuration - which is astra-sim config
+        The file values are set in the configuration object at: configruation.common_config.logging
+        """
+        try:
+            with open(logging_file_path, "r", encoding="utf-8") as toml_file:
+                toml_data = toml.load(toml_file)  # parses the TOML file into a Python dict
+
+            for sink in toml_data.get("sink", []):
+                configruation.common_config.logging.sink.add(**sink)
+            for logger in toml_data.get("logger", []):
+                configruation.common_config.logging.logger.add(**logger)
+        except Exception as e:
+            print(f"Error translating logging configuration from file '{logging_file_path}': {e}")
+            traceback.print_exc()
+            raise RuntimeError("Failed to translate logging configuration.") from e
+
+    @staticmethod
+    def _parse_htsim_topo(file_path: str) -> dict:
+        """
+        static private function used to parse htsim topology
+        """
+        result = {}
+        current_tier = None
+        with open(file_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                parts = line.split()
+                key = parts[0]
+
+                # check for Tier Section
+                if key == "Tier":
+                    tier_num = parts[1]
+                    current_tier = f"tier_{tier_num}"
+                    result[current_tier] = {}
+                    continue
+
+                value = parts[1] if len(parts) > 1 else None
+                if value is not None:
+                    try:
+                        value = int(value)
+                    except ValueError:
+                        try:
+                            value = float(value)
+                        except ValueError:
+                            pass
+                if current_tier:
+                    result[current_tier][key] = value
+                else:
+                    result[key] = value
+        return result

service_client_utils-0.1.0/service_client_utils.egg-info/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: service_client_utils
+Version: 0.1.0
+Requires-Dist: networkx
+Requires-Dist: pandas
+Requires-Dist: grpcio

service_client_utils-0.1.0/service_client_utils.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+service_client_utils/astra_sim.py
+service_client_utils/astra_sim_client.py
+service_client_utils/common.py
+service_client_utils/config_to_schema.py
+service_client_utils.egg-info/PKG-INFO
+service_client_utils.egg-info/SOURCES.txt
+service_client_utils.egg-info/dependency_links.txt
+service_client_utils.egg-info/requires.txt
+service_client_utils.egg-info/top_level.txt

service_client_utils-0.1.0/service_client_utils.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

service_client_utils-0.1.0/service_client_utils.egg-info/requires.txt

@@ -0,0 +1,3 @@
+networkx
+pandas
+grpcio

service_client_utils-0.1.0/service_client_utils.egg-info/top_level.txt

@@ -0,0 +1 @@
+service_client_utils

service_client_utils-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+