Update clients folder to adapters. Rename NetworkManagementInterface

def main():

    # The module that imports the SDK package, must specify which adapters will be used:

    client_specs = {

    adapter_specs = {

        "edgecloud": {

            "client_name": "i2edge",

            "client_name": "kubernetes",

            "base_url": "http://IP:PORT",

        },

        "network": {

        },

    }

    clients = sdkclient.create_clients_from(client_specs)

    edgecloud_client = clients.get("edgecloud")

    network_client = clients.get("network")

    adapters = sdkclient.create_adapters_from(adapter_specs)

    edgecloud_client = adapters.get("edgecloud")

    network_client = adapters.get("network")

    print("EdgeCloud client ready to be used:", edgecloud_client)

    print("Network client ready to be used:", network_client)

# Contributors:

#   - Adrián Pino Martínez (adrian.pino@i2cat.net)

##

from sunrise6g_opensdk.edgecloud.clients.aeros.client import (

from sunrise6g_opensdk.edgecloud.adapters.aeros.client import (

    EdgeApplicationManager as AerosClient,

)

from sunrise6g_opensdk.edgecloud.clients.i2edge.client import (

from sunrise6g_opensdk.edgecloud.adapters.i2edge.client import (

    EdgeApplicationManager as I2EdgeClient,

)

from sunrise6g_opensdk.network.clients.oai.client import NetworkManager as OaiCoreClient

from sunrise6g_opensdk.network.clients.open5gcore.client import (

from sunrise6g_opensdk.network.adapters.oai.client import (

    NetworkManager as OaiCoreClient,

)

from sunrise6g_opensdk.network.adapters.open5gcore.client import (

    NetworkManager as Open5GCoreClient,

)

from sunrise6g_opensdk.network.clients.open5gs.client import (

from sunrise6g_opensdk.network.adapters.open5gs.client import (

    NetworkManager as Open5GSClient,

)

# from sunrise6g_opensdk.edgecloud.clients.piedge.client import EdgeApplicationManager as PiEdgeClient

# from sunrise6g_opensdk.edgecloud.adapters.kubernetes.client import EdgeApplicationManager as kubernetesClient

def _edgecloud_factory(client_name: str, base_url: str, **kwargs):

def _edgecloud_adapters_factory(client_name: str, base_url: str, **kwargs):

    edge_cloud_factory = {

        "aeros": lambda url, **kw: AerosClient(base_url=url, **kw),

        "i2edge": lambda url: I2EdgeClient(base_url=url),

        # "piedge": lambda url: PiEdgeClient(base_url=url), Uncomment when import issues are solved

        # "kubernetes": lambda url: kubernetesClient(base_url=url), Uncomment when import issues are solved

    }

    try:

        return edge_cloud_factory[client_name](base_url, **kwargs)

        )

def _network_factory(client_name: str, base_url: str, **kwargs):

def _network_adapters_factory(client_name: str, base_url: str, **kwargs):

    if "scs_as_id" not in kwargs:

        raise ValueError("Missing required 'scs_as_id' for network clients.")

        raise ValueError("Missing required 'scs_as_id' for network adapters.")

    scs_as_id = kwargs.pop("scs_as_id")

    network_factory = {

        )

# def _oran_factory(client_name: str, base_url: str):

# def _oran_adapters_factory(client_name: str, base_url: str):

#     # TODO

class SdkFactory:

class AdaptersFactory:

    _domain_factories = {

        "edgecloud": _edgecloud_factory,

        "network": _network_factory,

        # "oran": _oran_factory,

        "edgecloud": _edgecloud_adapters_factory,

        "network": _network_adapters_factory,

        # "oran": _oran_adapters_factory,

    }

    @classmethod

    def instantiate_and_retrieve_clients(

    def instantiate_and_retrieve_adapters(

        cls, domain: str, client_name: str, base_url: str, **kwargs

    ):

        try:

##

from typing import Dict

from sunrise6g_opensdk.common.sdk_factory import SdkFactory

from sunrise6g_opensdk.common.adapters_factory import AdaptersFactory

class Sdk:

    @staticmethod

    def create_clients_from(

        client_specs: Dict[str, Dict[str, str]],

    def create_adapters_from(

        adapter_specs: Dict[str, Dict[str, str]],

    ) -> Dict[str, object]:

        """

        Create and return a dictionary of instantiated edgecloud/network/oran clients

        Create and return a dictionary of instantiated edgecloud/network/oran adapters

        based on the provided specifications.

        Args:

            client_specs (dict): A dictionary where each key is the client's domain (e.g., 'edgecloud', 'network'),

            adapter_specs (dict): A dictionary where each key is the client's domain (e.g., 'edgecloud', 'network'),

                                 and each value is a dictionary containing:

                                 - 'client_name' (str): The specific name of the client (e.g., 'i2edge', 'open5gs').

                                 - 'base_url' (str): The base URL for the client's API.

            dict: A dictionary where keys are the 'client_name' (str) and values are

                  the instantiated client objects.

        Example:

        # TODO: Update it

        # Example:

            >>> from src.common.universal_client_catalog import UniversalCatalogClient

            >>>

            >>> client_specs_example = {

            >>> adapter_specs_example = {

            >>>     'edgecloud': {

            >>>         'client_name': 'i2edge',

            >>>         'base_url': 'http://ip_edge_cloud:port',

            >>>     }

            >>> }

            >>>

            >>> clients = UniversalCatalogClient.create_clients(client_specs_example)

            >>> edgecloud_client = clients.get("edgecloud")

            >>> network_client = clients.get("network")

            >>>

            >>> edgecloud_client.get_edge_cloud_zones()

            >>> network_client.get_qod_session(session_id="example_session_id")

        """

        sdk_client = SdkFactory()

        clients = {}

        sdk_client = AdaptersFactory()

        adapters = {}

        for domain, config in client_specs.items():

        for domain, config in adapter_specs.items():

            client_name = config["client_name"]

            base_url = config["base_url"]

            # Support of additional paramaters for specific clients

            # Support of additional paramaters for specific adapters

            kwargs = {

                k: v for k, v in config.items() if k not in ("client_name", "base_url")

            }

            client = sdk_client.instantiate_and_retrieve_clients(

            client = sdk_client.instantiate_and_retrieve_adapters(

                domain, client_name, base_url, **kwargs

            )

            clients[domain] = client

            adapters[domain] = client

        return clients

        return adapters

    and an access token for authentication.

"""

from sunrise6g_opensdk.edgecloud.clients.aeros import config

from sunrise6g_opensdk.edgecloud.adapters.aeros import config

from sunrise6g_opensdk.logger import setup_logger

logger = setup_logger(__name__, is_debug=True, file_name=config.LOG_FILE)