diff --git a/src/compute/service/__main__.py b/src/compute/service/__main__.py index 9705e3187ffff633a4d127855c1c57afcf397e39..19a04c4c8ef4f77b3b7fb6949a1b567ef5cbec00 100644 --- a/src/compute/service/__main__.py +++ b/src/compute/service/__main__.py @@ -22,6 +22,7 @@ from .ComputeService import ComputeService from .rest_server.RestServer import RestServer from .rest_server.nbi_plugins.debug_api import register_debug_api from .rest_server.nbi_plugins.ietf_l2vpn import register_ietf_l2vpn +from .rest_server.nbi_plugins.ietf_network_slice import register_ietf_nss terminate = threading.Event() LOGGER = None @@ -58,8 +59,9 @@ def main(): grpc_service.start() rest_server = RestServer() + register_ietf_l2vpn(rest_server) # Registering L2VPN entrypoint + register_ietf_nss(rest_server) # Registering NSS entrypoint register_debug_api(rest_server) - register_ietf_l2vpn(rest_server) rest_server.start() # Wait for Ctrl+C or termination signal diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_Service.py b/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_Service.py index 2db231221faad1af2c7f0651dee2b95427e97acd..f12c4526aec27a60e579540ecae90720c707a117 100644 --- a/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_Service.py +++ b/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_Service.py @@ -20,8 +20,8 @@ from common.proto.context_pb2 import SliceStatusEnum from common.tools.context_queries.Slice import get_slice from context.client.ContextClient import ContextClient from slice.client.SliceClient import SliceClient -from .tools.Authentication import HTTP_AUTH -from .tools.HttpStatusCodes import HTTP_GATEWAYTIMEOUT, HTTP_NOCONTENT, HTTP_OK, HTTP_SERVERERROR +from ..tools.Authentication import HTTP_AUTH +from ..tools.HttpStatusCodes import HTTP_GATEWAYTIMEOUT, HTTP_NOCONTENT, HTTP_OK, HTTP_SERVERERROR LOGGER = logging.getLogger(__name__) diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_Services.py b/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_Services.py index dcdecb70ffff4059e557d1dadbbb958a4e264fab..69676bd0d0165160da4e64c515d04b5a3252102c 100644 --- a/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_Services.py +++ b/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_Services.py @@ -22,9 +22,9 @@ from common.Constants import DEFAULT_CONTEXT_NAME from common.proto.context_pb2 import SliceStatusEnum, Slice from slice.client.SliceClient import SliceClient from .schemas.vpn_service import SCHEMA_VPN_SERVICE -from .tools.Authentication import HTTP_AUTH -from .tools.HttpStatusCodes import HTTP_CREATED, HTTP_SERVERERROR -from .tools.Validator import validate_message +from compute.service.rest_server.nbi_plugins.tools.HttpStatusCodes import HTTP_CREATED, HTTP_SERVERERROR +from compute.service.rest_server.nbi_plugins.tools.Validator import validate_message +from compute.service.rest_server.nbi_plugins.tools.Authentication import HTTP_AUTH LOGGER = logging.getLogger(__name__) diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_SiteNetworkAccesses.py b/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_SiteNetworkAccesses.py index b89fa2207d1cd69e30612e8cecc8aa0f325e9dd3..ff7ad3c1481d3c0f3cdf7a6b6004f62677948ecc 100644 --- a/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_SiteNetworkAccesses.py +++ b/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/L2VPN_SiteNetworkAccesses.py @@ -30,11 +30,10 @@ from common.tools.grpc.Tools import grpc_message_to_json_string from context.client.ContextClient import ContextClient from slice.client.SliceClient import SliceClient from .schemas.site_network_access import SCHEMA_SITE_NETWORK_ACCESS -from .tools.Authentication import HTTP_AUTH -from .tools.HttpStatusCodes import HTTP_NOCONTENT, HTTP_SERVERERROR -from .tools.Validator import validate_message -from .Constants import ( - BEARER_MAPPINGS, DEFAULT_ADDRESS_FAMILIES, DEFAULT_BGP_AS, DEFAULT_BGP_ROUTE_TARGET, DEFAULT_MTU) +from compute.service.rest_server.nbi_plugins.tools.Authentication import HTTP_AUTH +from compute.service.rest_server.nbi_plugins.tools.HttpStatusCodes import HTTP_NOCONTENT, HTTP_SERVERERROR +from compute.service.rest_server.nbi_plugins.tools.Validator import validate_message +from .Constants import BEARER_MAPPINGS, DEFAULT_ADDRESS_FAMILIES, DEFAULT_BGP_AS, DEFAULT_BGP_ROUTE_TARGET, DEFAULT_MTU LOGGER = logging.getLogger(__name__) diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/NSS_Service.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/NSS_Service.py new file mode 100644 index 0000000000000000000000000000000000000000..f9b17c8b144ad6cf477b978ceb50b3497c9c074b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/NSS_Service.py @@ -0,0 +1,78 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import logging +from flask.json import jsonify +from flask_restful import Resource +from common.proto.context_pb2 import SliceStatusEnum +from common.tools.context_queries.Slice import get_slice +from common.tools.grpc.Tools import grpc_message_to_json +from context.client.ContextClient import ContextClient +from slice.client.SliceClient import SliceClient +from ..tools.Authentication import HTTP_AUTH +from ..tools.HttpStatusCodes import HTTP_GATEWAYTIMEOUT, HTTP_NOCONTENT, HTTP_OK, HTTP_SERVERERROR + +LOGGER = logging.getLogger(__name__) + +class NSS_Service(Resource): + @HTTP_AUTH.login_required + def get(self, slice_id : str): + LOGGER.debug('GET Slice ID: {:s}'.format(str(slice_id))) + try: + context_client = ContextClient() + + target = get_slice(context_client, slice_id, rw_copy=True) + if target is None: + raise Exception('Slice({:s}) not found in database'.format(str(slice_id))) + + if target.slice_id.slice_uuid.uuid != slice_id: # pylint: disable=no-member + raise Exception('Slice retrieval failed. Wrong Slice Id was returned') + + slice_ready_status = SliceStatusEnum.SLICESTATUS_ACTIVE + slice_status = target.slice_status.slice_status # pylint: disable=no-member + response = jsonify(grpc_message_to_json(target)) + response.status_code = HTTP_OK if slice_status == slice_ready_status else HTTP_GATEWAYTIMEOUT + + except Exception as e: # pylint: disable=broad-except + LOGGER.exception('Something went wrong Retrieving Slice({:s})'.format(str(slice_id))) + response = jsonify({'error': str(e)}) + response.status_code = HTTP_SERVERERROR + return response + + + @HTTP_AUTH.login_required + def delete(self, slice_id : str): + LOGGER.debug('DELETE Slice ID: {:s}'.format(str(slice_id))) + try: + context_client = ContextClient() + target = get_slice(context_client, slice_id) + + response = jsonify({}) + response.status_code = HTTP_OK + + if target is None: + LOGGER.warning('Slice({:s}) not found in database. Nothing done.'.format(str(slice_id))) + response.status_code = HTTP_NOCONTENT + else: + if target.slice_id.slice_uuid.uuid != slice_id: # pylint: disable=no-member + raise Exception('Slice retrieval failed. Wrong Slice Id was returned') + slice_client = SliceClient() + slice_client.DeleteSlice(target.slice_id) + LOGGER.debug(f"Slice({slice_id}) successfully deleted") + + except Exception as e: # pylint: disable=broad-except + LOGGER.exception('Something went wrong Deleting Slice({:s})'.format(str(slice_id))) + response = jsonify({'error': str(e)}) + response.status_code = HTTP_SERVERERROR + return response \ No newline at end of file diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/NSS_Services.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/NSS_Services.py new file mode 100644 index 0000000000000000000000000000000000000000..72b09f2b7d1422da2554a3dfe873a6bcff87413d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/NSS_Services.py @@ -0,0 +1,122 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import json +import logging +import ssl +import uuid +from typing import Dict +from flask.json import jsonify +from flask_restful import Resource +from flask import request + +from common.Constants import DEFAULT_CONTEXT_NAME +from common.proto.context_pb2 import Slice, SliceStatusEnum, EndPointId, Constraint +from common.tools.grpc.Tools import grpc_message_to_json +from ..tools.Authentication import HTTP_AUTH +from ..tools.HttpStatusCodes import HTTP_BADREQUEST, HTTP_OK, HTTP_CREATED, HTTP_SERVERERROR +from werkzeug.exceptions import UnsupportedMediaType + +from slice.client.SliceClient import SliceClient +from .bindings import load_json_data +from .bindings.network_slice_services import NetworkSliceServices + +LOGGER = logging.getLogger(__name__) + +class NSS_Services(Resource): + @HTTP_AUTH.login_required + def get(self): + response = jsonify({"message": "All went well!"}) + # TODO Return list of current network-slice-services + return response + + @HTTP_AUTH.login_required + def post(self): + if not request.is_json: + raise UnsupportedMediaType('JSON payload is required') + request_data = json.dumps(request.json) + response = jsonify({}) + response.status_code = HTTP_CREATED + + slices: NetworkSliceServices = load_json_data(request_data, NetworkSliceServices)[0] + for ietf_slice in slices.slice_service: + slice_request: Slice = Slice() + # Meta information + # TODO implement name and owner based on "tags" + slice_request.slice_id.context_id.context_uuid.uuid = DEFAULT_CONTEXT_NAME + slice_request.slice_id.slice_uuid.uuid = ietf_slice.service_id() + # TODO map with admin status of IETF Slice + slice_request.slice_status.slice_status = SliceStatusEnum.SLICESTATUS_PLANNED + + list_endpoints = [] + for sdp in ietf_slice.sdps().sdp: + endpoint = EndPointId() + endpoint.topology_id.context_id.context_uuid.uuid = DEFAULT_CONTEXT_NAME + endpoint.device_id.device_uuid.uuid = sdp.node_id() + endpoint.endpoint_uuid.uuid = sdp.sdp_id() + list_endpoints.append(endpoint) + slice_request.slice_endpoint_ids.extend(list_endpoints) + + # TODO Map connectivity_groups and connectivity constructs to real connections + LOGGER.debug(f"Connection groups detected: {len(ietf_slice.connection_groups().connection_group())}") + list_constraints = [] + for cg in ietf_slice.connection_groups().connection_group: + for cc in cg.connectivity_construct: + if cc.slo_sle_policy.custom: + with cc.slo_sle_policy.custom as slo: + for metric_bound in slo.service_slo_sle_policy().metric_bounds().metric_bound: + metric_type = str(metric_bound.metric_type()).casefold() + if metric_type == "service-slo-two-way-bandwidth": # TODO fix to two way! + constraint = Constraint() + metric_unit = metric_bound.metric_unit().casefold() + capacity = float(metric_bound.bound()) # Assuming capacity already in Gbps + if metric_unit == "mbps": + capacity /= 1E3 + elif metric_unit != "gbps": + LOGGER.warning(f"Invalided metric unit ({metric_bound.metric_unit()}), must be Mbps or Gbps") + response.status_code = HTTP_SERVERERROR + return response + constraint.sla_capacity.capacity_gbps = capacity + list_constraints.append(constraint) + + elif metric_type == "service-slo-one-way-delay": + if metric_bound.metric_unit().casefold() == "ms": + latency = int(metric_bound.bound()) + else: + LOGGER.warning(f"Invalided metric unit ({metric_bound.metric_unit()}), must be \"ms\" ") + response.status_code = HTTP_SERVERERROR + return response + constraint = Constraint() + constraint.sla_latency.e2e_latency_ms = latency + list_constraints.append(constraint) + + elif metric_type == "service-slo-availability": + availability = float(metric_bound.bound()) + if availability > 100.0 or availability < 0.0: + raise Exception(f'Slice SLO availability ({availability}) must be constrained [0,100]') + constraint = Constraint() + constraint.sla_availability.availability = availability + # TODO not really necessary, remove after OFC2023 + constraint.sla_availability.num_disjoint_paths = 0 + constraint.sla_availability.all_active = False + list_constraints.append(constraint) + + slice_request.slice_constraints.extend(list_constraints) + LOGGER.debug(grpc_message_to_json(slice_request)) # TODO remove + # TODO adding owner, needs to be recoded after updating the bindings + owner = request.json["data"]["ietf-network-slice-service:network-slice-services"]["slice-service"][0]["service-tags"][0]["value"] + slice_request.slice_owner.owner_string = owner + slice_request.slice_owner.owner_uuid.uuid = str(uuid.uuid5(uuid.NAMESPACE_DNS, owner)) + slice_client = SliceClient() + slice_client.CreateSlice(slice_request) + return response diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8aca124acfd15b2003b4272cf0b3103dbca3bdb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/__init__.py @@ -0,0 +1,31 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# IETF draft-ietf-teas-ietf-network-slice-nbi-yang-02 - IETF Network Slice Service YANG Model +# Ref: https://datatracker.ietf.org/doc/draft-ietf-teas-ietf-network-slice-nbi-yang/ + +from flask_restful import Resource +from compute.service.rest_server.RestServer import RestServer +from .NSS_Services import NSS_Services +from .NSS_Service import NSS_Service + +URL_PREFIX = '/data/ietf-network-slice-service:ietf-nss' + +def _add_resource(rest_server : RestServer, resource : Resource, *urls, **kwargs): + urls = [(URL_PREFIX + url) for url in urls] + rest_server.add_resource(resource, *urls, **kwargs) + +def register_ietf_nss(rest_server : RestServer): + _add_resource(rest_server, NSS_Services, '/network-slice-services') + _add_resource(rest_server, NSS_Service, '/network-slice-services/slice-service=') diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7a0c786e1defad55a4dcc20461b221472d3be687 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/__init__.py @@ -0,0 +1,535 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from itertools import chain +from typing import ( + Any, AnyStr, Dict, Iterator, List, Optional, Tuple, Type, Union) + +import json + + +class YANGMember: + + _yang_name: str = None + _yang_namespace: str = None + _yang_module_name: str = None + + def __init__( + self, yang_name: str, yang_namespace: str, + yang_module_name: str): + + self._yang_name = yang_name + self._yang_namespace = yang_namespace + self._yang_module_name = yang_module_name + + @property + def yang_name(self) -> str: + return self._yang_name + + @property + def yang_namespace(self) -> str: + return self._yang_namespace + + @property + def yang_module_name(self) -> str: + return self._yang_module_name + + +class YANGLeafMember(YANGMember): + + def __get__(self, instance, owner=None): + if instance is None: + return self + + yang_name = self._yang_name + yang_member = self + + class ChildLeaf: + + def __call__(self): + data = instance._data + if (key := yang_name) in data: + return data[key] + + return data.get(':'.join(( + yang_member._yang_module_name, yang_name))) + + @property + def yang_name(self) -> str: + return yang_member._yang_name + + @property + def yang_namespace(self) -> str: + return yang_member._yang_namespace + + @property + def yang_module_name(self) -> str: + return yang_member._yang_module_name + + def __enter__(self): + return self() + + def __exit__(self, exc_type, exc, traceback): + if exc is not None: + raise exc + + def __repr__(self): + return ( + f"<{owner.__qualname__}.{type(self).__name__}: " + + f"{yang_member._yang_module_name}" + + f":{yang_member.yang_name}>") + + return ChildLeaf() + + def __set__(self, instance, value): + if instance is None: + return + + data = instance._data + if ((key := ':'.join((self._yang_module_name, self._yang_name))) + in data): + + data[key] = value + else: + data[self._yang_name] = value + + +class YANGContainerMember(YANGMember): + + _yang_container_type: Type['YANGContainer'] = None + + def __init__(self, yang_container_type: Type['YANGContainer']): + super().__init__( + yang_container_type._yang_name, + yang_container_type._yang_namespace, + yang_container_type._yang_module_name) + + self._yang_container_type = yang_container_type + + def __get__(self, instance, owner=None): + if instance is None: + return self + + yang_container_type = self._yang_container_type + yang_name = self._yang_name + yang_member = self + + class ChildContainer: + + def __call__(self) -> yang_container_type: + data = instance._data + + if (key := ':'.join(( + yang_member._yang_module_name, yang_name))) in data: + + child_data = data[key] + else: + child_data = data.setdefault(yang_name, {}) + + return yang_container_type({yang_name: child_data}) + + @property + def yang_name(self) -> str: + return yang_member._yang_name + + @property + def yang_namespace(self) -> str: + return yang_member._yang_namespace + + @property + def yang_module_name(self) -> str: + return yang_member._yang_module_name + + def __enter__(self): + return self() + + def __exit__(self, exc_type, exc, traceback): + if exc is not None: + raise exc + + def to_json(self, yang_parent_module_name: str=None): + return self().to_json( + yang_parent_module_name=yang_parent_module_name) + + return ChildContainer() + + +class YANGListMember(YANGMember): + + _yang_list_item_type: Type['YANGListItem'] = None + + def __init__(self, yang_list_item_type: Type['YANGListItem']): + super().__init__( + yang_list_item_type._yang_name, + yang_list_item_type._yang_namespace, + yang_list_item_type._yang_module_name) + + self._yang_list_item_type = yang_list_item_type + + def __get__(self, instance, owner=None): + if instance is None: + return self + + yang_list_item_type = self._yang_list_item_type + yang_name = self._yang_name + yang_member = self + + class ChildList: + + @staticmethod + def _child_data_list(): + data = instance._data + if (key := ':'.join(( + yang_member._yang_module_name, yang_name))) in data: + + return data[key] + + return data.setdefault(yang_name, []) + + def __call__(self) -> List[yang_list_item_type]: + return list(iter(self)) + + def __iter__(self) -> Iterator[yang_list_item_type]: + for child_data in self._child_data_list(): + yield yang_list_item_type({yang_name: [child_data]}) + + def __getitem__(self, key) -> yang_list_item_type: + child_data_list = self._child_data_list() + child = yang_list_item_type( + {yang_member._yang_name: child_data_list}, + json_data_list_key=key) + + if not id(child_data := child._data) in map( + id, child_data_list): + child_data_list.append(child_data) + return child + + @property + def yang_name(self) -> str: + return yang_member._yang_name + + @property + def yang_namespace(self) -> str: + return yang_member._yang_namespace + + @property + def yang_module_name(self) -> str: + return yang_member._yang_module_name + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc, traceback): + if exc is not None: + raise exc + + def to_json(self, yang_parent_module_name=None): + json_data = {} + for child in self(): + for child_name, child_data_list in (child.to_json( + yang_parent_module_name=( + yang_parent_module_name))).items(): + + json_data.setdefault(child_name, []).extend( + child_data_list) + + return json_data + + return ChildList() + + +class YANGContainer: + """Base class for YANG container handlers.""" + + _yang_name: str = None + _yang_namespace: str = None + _yang_module_name: str = None + + _data: Dict[str, Any] = None + + _yang_leaf_members: Dict[str, YANGLeafMember] = None + _yang_container_members: Dict[str, YANGContainerMember] = None + _yang_list_members: Dict[str, YANGListMember] = None + + _yang_choices: Dict[str, 'YANGChoice'] = None + + def __init__( + self, json_data: Optional[Union[AnyStr, Dict[str, Any]]]=None): + + if json_data is None: + self._data = {} + return + + if isinstance(json_data, bytes): + json_data = json_data.decode('utf8') + + if isinstance(json_data, str): + json_data = json.loads(json_data) + + if (key := ':'.join(( + self._yang_module_name, self._yang_name))) not in json_data: + key = self._yang_name + + data = json_data.get(key, {}) + if not isinstance(data, dict): + raise TypeError(f"{key!r} should be a dict, not: {type(data)}") + + for yang_choice in self._yang_choices.values(): + yang_choice(data) + + self._data = data + + @property + def yang_name(self) -> str: + return self._yang_name + + @property + def yang_namespace(self) -> str: + return self._yang_namespace + + @property + def yang_module_name(self) -> str: + return self._yang_module_name + + def to_json(self, yang_parent_module_name=None) -> Dict[str, Any]: + + def child_items(): + for yang_name, yang_member in self._yang_leaf_members.items(): + if (value := yang_member.__get__(self)()) is not None: + + if (yang_child_module_name := + yang_member.yang_module_name) != ( + self._yang_module_name): + + child_key = ':'.join(( + yang_child_module_name, yang_name)) + else: + child_key = yang_name + + yield child_key, value + + for yang_name, yang_member in ( + self._yang_container_members.items()): + + if yang_name in self._data or ':'.join(( + yang_member._yang_namespace, + yang_name)) in self._data: + + yield from yang_member.__get__(self).to_json( + yang_parent_module_name=( + self._yang_module_name)).items() + + for yang_name, yang_member in self._yang_list_members.items(): + if yang_name in self._data or ':'.join(( + yang_member._yang_namespace, + yang_name)) in self._data: + + yield from yang_member.__get__(self).to_json( + yang_parent_module_name=( + self._yang_module_name)).items() + + for yang_choice in self._yang_choices.values(): + if (yang_case_container := + yang_choice._yang_case_container) is not None: + + yield from next(iter(yang_case_container.to_json( + yang_parent_module_name=( + self._yang_module_name)).values())).items() + + if (yang_module_name := self._yang_module_name) != ( + yang_parent_module_name): + key = ':'.join((yang_module_name, self._yang_name)) + else: + key = self._yang_name + + return {key: dict(child_items())} + + +class YANGListItem(YANGContainer): + """Base class for YANG list item handlers.""" + + _yang_list_key_names: Tuple[str] = None + + def __init__( + self, json_data: Optional[Union[AnyStr, Dict[str, Any]]]=None, + json_data_list_key=None): + + if json_data is None: + raise ValueError(f"{self._yang_name!r} list needs input data") + + if isinstance(json_data, bytes): + json_data = json_data.decode('utf8') + + if isinstance(json_data, str): + json_data = json.loads(json_data) + + if (key := ':'.join(( + self._yang_module_name, self._yang_name))) not in json_data: + key = self._yang_name + + data_list = json_data.get(key, []) + if not isinstance(data_list, list): + raise TypeError( + f"{key!r} should be a list, not: {type(data_list)}") + + if json_data_list_key is None: + if len(data_list) == 1: + data = data_list[0] + else: + raise ValueError(f"{key!r} list key is missing") + + else: + if not isinstance(json_data_list_key, tuple): + json_data_list_key = (json_data_list_key, ) + + for data in json_data.get(key, []): + if tuple( + data.get(yang_name) for yang_name + in self._yang_list_key_names) == json_data_list_key: + + break + else: + data = {key: value for key, value in zip( + self._yang_list_key_names, json_data_list_key)} + + if not isinstance(data, dict): + raise TypeError( + f"{key!r} list item should be a dict, not: {type(data)}") + + for yang_choice in self._yang_choices.values(): + yang_choice(data) + + self._data = data + + def yang_key(self): + if len(self._yang_list_key_names) == 1: + return self._yang_leaf_members[ + self._yang_list_key_names[0]].__get__(self)() + + return tuple( + self._yang_leaf_members[yang_name].__get__(self)() + for yang_name in self._yang_list_key_names) + + def to_json(self, yang_parent_module_name=None) -> Dict[str, list]: + return {key: [data] for key, data in super().to_json( + yang_parent_module_name=yang_parent_module_name).items()} + + +class YANGChoiceCase: + """Base class for YANG choice case handlers.""" + + _yang_name: str = None + + _yang_container_type: Type[YANGContainer] = None + + _yang_container: YANGContainer = None + + def __init__(self, yang_container_type: Type[YANGContainer]): + self._yang_container_type = yang_container_type + self._yang_name = yang_container_type._yang_name + + @property + def yang_name(self) -> str: + return self._yang_name + + def __get__(self, instance, owner=None): + if instance is None: + return self + + yang_case_container_type = self._yang_container_type + yang_name = self._yang_name + yang_choice_case = self + + class Case: + + def __bool__(self) -> bool: + return (yang_case_container := + yang_choice_case._yang_container) is not None and ( + bool(yang_case_container._data)) + + def __call__(self, data: Optional[Dict[str, Any]]=None): + if data: + for yang_member in chain( + yang_case_container_type. + _yang_leaf_members.values(), + + yang_case_container_type. + _yang_container_members.values(), + + yang_case_container_type. + _yang_list_members.values()): + + if yang_member._yang_name in data or ':'.join(( + yang_member._yang_module_name, + yang_member._yang_name)) in data: + break + else: + data = None + + if data: + yang_choice_case._yang_container = ( + yang_case_container_type({yang_name: data})) + + elif yang_choice_case._yang_container is None: + yang_choice_case._yang_container = ( + yang_case_container_type()) + + return yang_choice_case._yang_container + + def __enter__(self): + return self() + + def __exit__(self, exc_type, exc, traceback): + if exc is not None: + raise exc + + return Case() + + +class YANGChoice(YANGMember): + """Base class for YANG choice handlers.""" + + _yang_parent: YANGContainer = None + + _yang_cases: Dict[str, YANGChoiceCase] = None + + def __init__(self, yang_parent: YANGContainer): + self._yang_parent = yang_parent + + def __call__(self, data: Dict[str, Any]): + for yang_case in self._yang_cases.values(): + yang_case.__get__(self)(data) + + @property + def _yang_case_container(self) -> YANGContainer: + for yang_case in self._yang_cases.values(): + if (yang_container := + yang_case._yang_container) is not None and ( + yang_container._data): + return yang_container + + +def load_json_data( + json_data: Union[AnyStr, Dict[str, Any]], + *yang_types: Type[YANGContainer]) -> List[YANGContainer]: + + if isinstance(json_data, bytes): + json_data = json_data.decode('utf8') + + if isinstance(json_data, str): + json_data = json.loads(json_data) + + json_data = json_data.get('data', json_data) + + return [yang_type(json_data) for yang_type in yang_types] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c5a00cae7ce23108a5db10e6192b315330e3a86b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/__init__.py @@ -0,0 +1,141 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NacmMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: nacm + """ + from .groups import Groups + from .rule_list import RuleList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: nacm + """ + + def __init__(self): + super().__init__(Nacm) + + def __get__(self, instance, owner=None) -> ( + 'NacmMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Nacm': + pass + + def __enter__(self) -> 'Nacm': + pass + + +class Nacm( + YANGContainer, + metaclass=NacmMeta): + """ + YANG container handler. + + YANG name: nacm + """ + + _yang_name: Final[str] = 'nacm' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm' + _yang_module_name: Final[str] = 'ietf-netconf-acm' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'denied-data-writes': ( + denied_data_writes := YANGLeafMember( + 'denied-data-writes', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + + 'exec-default': ( + exec_default := YANGLeafMember( + 'exec-default', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + + 'denied-notifications': ( + denied_notifications := YANGLeafMember( + 'denied-notifications', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + + 'enable-external-groups': ( + enable_external_groups := YANGLeafMember( + 'enable-external-groups', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + + 'enable-nacm': ( + enable_nacm := YANGLeafMember( + 'enable-nacm', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + + 'read-default': ( + read_default := YANGLeafMember( + 'read-default', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + + 'denied-operations': ( + denied_operations := YANGLeafMember( + 'denied-operations', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + + 'write-default': ( + write_default := YANGLeafMember( + 'write-default', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'groups': ( + groups := ( # YANGContainerMember( + NacmMeta. + Groups. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'rule-list': ( + rule_list := ( # YANGListMember( + NacmMeta. + RuleList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Nacm': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/groups/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/groups/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e95275ad804d53820f3fc4a0210d60c645a70d14 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/groups/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GroupsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: groups + """ + from .group import Group + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: groups + """ + + def __init__(self): + super().__init__(Groups) + + def __get__(self, instance, owner=None) -> ( + 'GroupsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Groups': + pass + + def __enter__(self) -> 'Groups': + pass + + +class Groups( + YANGContainer, + metaclass=GroupsMeta): + """ + YANG container handler. + + YANG name: groups + """ + + _yang_name: Final[str] = 'groups' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm' + _yang_module_name: Final[str] = 'ietf-netconf-acm' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'group': ( + group := ( # YANGListMember( + GroupsMeta. + Group. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Groups': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/groups/group/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/groups/group/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c294bb266b4b8f6416b1ffe0ea59276c5a109b0f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/groups/group/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GroupMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: group + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: group + """ + + def __init__(self): + super().__init__(Group) + + def __get__(self, instance, owner=None) -> ( + 'GroupMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Group']: + pass + + def __iter__(self, key) -> Iterator['Group']: + return super().__iter__() + + def __getitem__(self, key) -> 'Group': + return super()[key] + + def __enter__(self) -> ( + 'GroupMeta.yang_list_descriptor'): + pass + + +class Group( + YANGListItem, + metaclass=GroupMeta): + """ + YANG list item handler. + + YANG name: group + """ + + _yang_name: Final[str] = 'group' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm' + _yang_module_name: Final[str] = 'ietf-netconf-acm' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Group': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dd0f9808e43dd3930efcec86b5b484b4107b77f6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RuleListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: rule-list + """ + from .rule import Rule + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: rule-list + """ + + def __init__(self): + super().__init__(RuleList) + + def __get__(self, instance, owner=None) -> ( + 'RuleListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RuleList']: + pass + + def __iter__(self, key) -> Iterator['RuleList']: + return super().__iter__() + + def __getitem__(self, key) -> 'RuleList': + return super()[key] + + def __enter__(self) -> ( + 'RuleListMeta.yang_list_descriptor'): + pass + + +class RuleList( + YANGListItem, + metaclass=RuleListMeta): + """ + YANG list item handler. + + YANG name: rule-list + """ + + _yang_name: Final[str] = 'rule-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm' + _yang_module_name: Final[str] = 'ietf-netconf-acm' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'rule': ( + rule := ( # YANGListMember( + RuleListMeta. + Rule. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RuleList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4ec5ba06dbf93901881ab6045d1896b85583a642 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/__init__.py @@ -0,0 +1,130 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RuleMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: rule + """ + from .rule_type import RuleType + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: rule + """ + + def __init__(self): + super().__init__(Rule) + + def __get__(self, instance, owner=None) -> ( + 'RuleMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Rule']: + pass + + def __iter__(self, key) -> Iterator['Rule']: + return super().__iter__() + + def __getitem__(self, key) -> 'Rule': + return super()[key] + + def __enter__(self) -> ( + 'RuleMeta.yang_list_descriptor'): + pass + + +class Rule( + YANGListItem, + metaclass=RuleMeta): + """ + YANG list item handler. + + YANG name: rule + """ + + _yang_name: Final[str] = 'rule' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm' + _yang_module_name: Final[str] = 'ietf-netconf-acm' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'action': ( + action := YANGLeafMember( + 'action', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + + 'access-operations': ( + access_operations := YANGLeafMember( + 'access-operations', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + + 'comment': ( + comment := YANGLeafMember( + 'comment', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + + 'module-name': ( + module_name := YANGLeafMember( + 'module-name', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Rule': + instance = super().__new__(cls) + instance._yang_choices = { + + 'rule-type': + RuleMeta.RuleType( + instance), + } + return instance + + @property + def rule_type(self) -> ( + RuleMeta.RuleType): + return self._yang_choices['rule-type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d470943c38427e03302d60c52cf22cdb16597d37 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/__init__.py @@ -0,0 +1,130 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RuleTypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: rule-type + """ + + from .notification import Notification + from .protocol_operation import ProtocolOperation + from .data_node import DataNode + + class notification_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: notification + """ + + def __init__(self): + super().__init__( + RuleTypeMeta.Notification) + + def __get__(self, instance, owner=None) -> ( + 'RuleTypeMeta.notification_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'RuleTypeMeta.Notification'): + pass + + def __enter__(self) -> ( + 'RuleTypeMeta.Notification'): + pass + + class protocol_operation_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: protocol-operation + """ + + def __init__(self): + super().__init__( + RuleTypeMeta.ProtocolOperation) + + def __get__(self, instance, owner=None) -> ( + 'RuleTypeMeta.protocol_operation_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'RuleTypeMeta.ProtocolOperation'): + pass + + def __enter__(self) -> ( + 'RuleTypeMeta.ProtocolOperation'): + pass + + class data_node_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: data-node + """ + + def __init__(self): + super().__init__( + RuleTypeMeta.DataNode) + + def __get__(self, instance, owner=None) -> ( + 'RuleTypeMeta.data_node_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'RuleTypeMeta.DataNode'): + pass + + def __enter__(self) -> ( + 'RuleTypeMeta.DataNode'): + pass + + +class RuleType(YANGChoice, metaclass=RuleTypeMeta): + """ + YANG choice handler. + + YANG name: rule-type + """ + + _yang_name: Final[str] = 'rule-type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm' + _yang_module_name: Final[str] = 'ietf-netconf-acm' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'notification': ( + notification := ( # YANGChoiceCase( + RuleTypeMeta. + notification_case_descriptor())), + + 'protocol-operation': ( + protocol_operation := ( # YANGChoiceCase( + RuleTypeMeta. + protocol_operation_case_descriptor())), + + 'data-node': ( + data_node := ( # YANGChoiceCase( + RuleTypeMeta. + data_node_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/data_node/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/data_node/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4f7ddf138eefd0c4a086a06a2b846e74bf45b1f6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/data_node/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class DataNodeMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: data-node + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: data-node + """ + + def __init__(self): + super().__init__(DataNode) + + def __get__(self, instance, owner=None) -> ( + 'DataNodeMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'DataNode': + pass + + def __enter__(self) -> 'DataNode': + pass + + +class DataNode( + YANGContainer, + metaclass=DataNodeMeta): + """ + YANG container handler. + + YANG name: data-node + """ + + _yang_name: Final[str] = 'data-node' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm' + _yang_module_name: Final[str] = 'ietf-netconf-acm' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path': ( + path := YANGLeafMember( + 'path', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'DataNode': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/notification/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/notification/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ed29784183bf0d387a6c4facd935e0870251e560 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/notification/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NotificationMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: notification + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: notification + """ + + def __init__(self): + super().__init__(Notification) + + def __get__(self, instance, owner=None) -> ( + 'NotificationMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Notification': + pass + + def __enter__(self) -> 'Notification': + pass + + +class Notification( + YANGContainer, + metaclass=NotificationMeta): + """ + YANG container handler. + + YANG name: notification + """ + + _yang_name: Final[str] = 'notification' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm' + _yang_module_name: Final[str] = 'ietf-netconf-acm' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'notification-name': ( + notification_name := YANGLeafMember( + 'notification-name', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Notification': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/protocol_operation/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/protocol_operation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1371c9edb91fac8da7f5bcdb3854d5dbc8cc2d1d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/nacm/rule_list/rule/rule_type/protocol_operation/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ProtocolOperationMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: protocol-operation + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: protocol-operation + """ + + def __init__(self): + super().__init__(ProtocolOperation) + + def __get__(self, instance, owner=None) -> ( + 'ProtocolOperationMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ProtocolOperation': + pass + + def __enter__(self) -> 'ProtocolOperation': + pass + + +class ProtocolOperation( + YANGContainer, + metaclass=ProtocolOperationMeta): + """ + YANG container handler. + + YANG name: protocol-operation + """ + + _yang_name: Final[str] = 'protocol-operation' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm' + _yang_module_name: Final[str] = 'ietf-netconf-acm' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'rpc-name': ( + rpc_name := YANGLeafMember( + 'rpc-name', + 'urn:ietf:params:xml:ns:yang:ietf-netconf-acm', + 'ietf-netconf-acm')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ProtocolOperation': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..296b880921a48cd2087ba3a9f82c18324e03d7b0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NetworkSliceServicesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: network-slice-services + """ + from .slo_sle_templates import SloSleTemplates + from .slice_service import SliceService + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: network-slice-services + """ + + def __init__(self): + super().__init__(NetworkSliceServices) + + def __get__(self, instance, owner=None) -> ( + 'NetworkSliceServicesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NetworkSliceServices': + pass + + def __enter__(self) -> 'NetworkSliceServices': + pass + + +class NetworkSliceServices( + YANGContainer, + metaclass=NetworkSliceServicesMeta): + """ + YANG container handler. + + YANG name: network-slice-services + """ + + _yang_name: Final[str] = 'network-slice-services' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'slo-sle-templates': ( + slo_sle_templates := ( # YANGContainerMember( + NetworkSliceServicesMeta. + SloSleTemplates. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'slice-service': ( + slice_service := ( # YANGListMember( + NetworkSliceServicesMeta. + SliceService. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NetworkSliceServices': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0e8520f1b36270cbc09d1acddda316eb7198c535 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/__init__.py @@ -0,0 +1,147 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SliceServiceMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: slice-service + """ + from .connection_groups import ConnectionGroups + from .te_topology_identifier import TeTopologyIdentifier + from .status import Status + from .sdps import Sdps + from .service_tags import ServiceTags + from .slo_sle_policy import SloSlePolicy + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: slice-service + """ + + def __init__(self): + super().__init__(SliceService) + + def __get__(self, instance, owner=None) -> ( + 'SliceServiceMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['SliceService']: + pass + + def __iter__(self, key) -> Iterator['SliceService']: + return super().__iter__() + + def __getitem__(self, key) -> 'SliceService': + return super()[key] + + def __enter__(self) -> ( + 'SliceServiceMeta.yang_list_descriptor'): + pass + + +class SliceService( + YANGListItem, + metaclass=SliceServiceMeta): + """ + YANG list item handler. + + YANG name: slice-service + """ + + _yang_name: Final[str] = 'slice-service' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'service-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'service-id': ( + service_id := YANGLeafMember( + 'service-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'service-description': ( + service_description := YANGLeafMember( + 'service-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'connection-groups': ( + connection_groups := ( # YANGContainerMember( + SliceServiceMeta. + ConnectionGroups. + yang_container_descriptor())), + + 'te-topology-identifier': ( + te_topology_identifier := ( # YANGContainerMember( + SliceServiceMeta. + TeTopologyIdentifier. + yang_container_descriptor())), + + 'status': ( + status := ( # YANGContainerMember( + SliceServiceMeta. + Status. + yang_container_descriptor())), + + 'sdps': ( + sdps := ( # YANGContainerMember( + SliceServiceMeta. + Sdps. + yang_container_descriptor())), + + 'service-tags': ( + service_tags := ( # YANGContainerMember( + SliceServiceMeta. + ServiceTags. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SliceService': + instance = super().__new__(cls) + instance._yang_choices = { + + 'slo-sle-policy': + SliceServiceMeta.SloSlePolicy( + instance), + } + return instance + + @property + def slo_sle_policy(self) -> ( + SliceServiceMeta.SloSlePolicy): + return self._yang_choices['slo-sle-policy'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a67fcd383e6ecaabe98b4aa1c1d892f68d21840f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ConnectionGroupsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: connection-groups + """ + from .connection_group import ConnectionGroup + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: connection-groups + """ + + def __init__(self): + super().__init__(ConnectionGroups) + + def __get__(self, instance, owner=None) -> ( + 'ConnectionGroupsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ConnectionGroups': + pass + + def __enter__(self) -> 'ConnectionGroups': + pass + + +class ConnectionGroups( + YANGContainer, + metaclass=ConnectionGroupsMeta): + """ + YANG container handler. + + YANG name: connection-groups + """ + + _yang_name: Final[str] = 'connection-groups' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'connection-group': ( + connection_group := ( # YANGListMember( + ConnectionGroupsMeta. + ConnectionGroup. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ConnectionGroups': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..38302dd8447f8af0dc7f4e9f133b2337ef8ef3c4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/__init__.py @@ -0,0 +1,132 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ConnectionGroupMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: connection-group + """ + from .connection_group_monitoring import ConnectionGroupMonitoring + from .connectivity_construct import ConnectivityConstruct + from .slo_sle_policy import SloSlePolicy + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: connection-group + """ + + def __init__(self): + super().__init__(ConnectionGroup) + + def __get__(self, instance, owner=None) -> ( + 'ConnectionGroupMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['ConnectionGroup']: + pass + + def __iter__(self, key) -> Iterator['ConnectionGroup']: + return super().__iter__() + + def __getitem__(self, key) -> 'ConnectionGroup': + return super()[key] + + def __enter__(self) -> ( + 'ConnectionGroupMeta.yang_list_descriptor'): + pass + + +class ConnectionGroup( + YANGListItem, + metaclass=ConnectionGroupMeta): + """ + YANG list item handler. + + YANG name: connection-group + """ + + _yang_name: Final[str] = 'connection-group' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'connection-group-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'connectivity-type': ( + connectivity_type := YANGLeafMember( + 'connectivity-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'connection-group-id': ( + connection_group_id := YANGLeafMember( + 'connection-group-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'service-slo-sle-policy-override': ( + service_slo_sle_policy_override := YANGLeafMember( + 'service-slo-sle-policy-override', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'connection-group-monitoring': ( + connection_group_monitoring := ( # YANGContainerMember( + ConnectionGroupMeta. + ConnectionGroupMonitoring. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'connectivity-construct': ( + connectivity_construct := ( # YANGListMember( + ConnectionGroupMeta. + ConnectivityConstruct. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ConnectionGroup': + instance = super().__new__(cls) + instance._yang_choices = { + + 'slo-sle-policy': + ConnectionGroupMeta.SloSlePolicy( + instance), + } + return instance + + @property + def slo_sle_policy(self) -> ( + ConnectionGroupMeta.SloSlePolicy): + return self._yang_choices['slo-sle-policy'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connection_group_monitoring/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connection_group_monitoring/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..395aabd46097a05d51746b4298b5fa845a369068 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connection_group_monitoring/__init__.py @@ -0,0 +1,127 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ConnectionGroupMonitoringMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: connection-group-monitoring + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: connection-group-monitoring + """ + + def __init__(self): + super().__init__(ConnectionGroupMonitoring) + + def __get__(self, instance, owner=None) -> ( + 'ConnectionGroupMonitoringMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ConnectionGroupMonitoring': + pass + + def __enter__(self) -> 'ConnectionGroupMonitoring': + pass + + +class ConnectionGroupMonitoring( + YANGContainer, + metaclass=ConnectionGroupMonitoringMeta): + """ + YANG container handler. + + YANG name: connection-group-monitoring + """ + + _yang_name: Final[str] = 'connection-group-monitoring' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'one-way-delay-variation': ( + one_way_delay_variation := YANGLeafMember( + 'one-way-delay-variation', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'one-way-max-delay': ( + one_way_max_delay := YANGLeafMember( + 'one-way-max-delay', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'one-way-packet-loss': ( + one_way_packet_loss := YANGLeafMember( + 'one-way-packet-loss', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'two-way-max-delay': ( + two_way_max_delay := YANGLeafMember( + 'two-way-max-delay', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'two-way-min-delay': ( + two_way_min_delay := YANGLeafMember( + 'two-way-min-delay', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'one-way-min-delay': ( + one_way_min_delay := YANGLeafMember( + 'one-way-min-delay', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'two-way-packet-loss': ( + two_way_packet_loss := YANGLeafMember( + 'two-way-packet-loss', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'two-way-delay-variation': ( + two_way_delay_variation := YANGLeafMember( + 'two-way-delay-variation', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ConnectionGroupMonitoring': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..124ac4ddc30dc414c79160077a4fc4042924472e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ConnectivityConstructMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: connectivity-construct + """ + from .connectivity_construct_monitoring import ConnectivityConstructMonitoring + from .slo_sle_policy import SloSlePolicy + from .connectivity_construct_type import ConnectivityConstructType + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: connectivity-construct + """ + + def __init__(self): + super().__init__(ConnectivityConstruct) + + def __get__(self, instance, owner=None) -> ( + 'ConnectivityConstructMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['ConnectivityConstruct']: + pass + + def __iter__(self, key) -> Iterator['ConnectivityConstruct']: + return super().__iter__() + + def __getitem__(self, key) -> 'ConnectivityConstruct': + return super()[key] + + def __enter__(self) -> ( + 'ConnectivityConstructMeta.yang_list_descriptor'): + pass + + +class ConnectivityConstruct( + YANGListItem, + metaclass=ConnectivityConstructMeta): + """ + YANG list item handler. + + YANG name: connectivity-construct + """ + + _yang_name: Final[str] = 'connectivity-construct' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'cc-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'service-slo-sle-policy-override': ( + service_slo_sle_policy_override := YANGLeafMember( + 'service-slo-sle-policy-override', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'cc-id': ( + cc_id := YANGLeafMember( + 'cc-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'connectivity-construct-monitoring': ( + connectivity_construct_monitoring := ( # YANGContainerMember( + ConnectivityConstructMeta. + ConnectivityConstructMonitoring. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ConnectivityConstruct': + instance = super().__new__(cls) + instance._yang_choices = { + + 'slo-sle-policy': + ConnectivityConstructMeta.SloSlePolicy( + instance), + + 'connectivity-construct-type': + ConnectivityConstructMeta.ConnectivityConstructType( + instance), + } + return instance + + @property + def slo_sle_policy(self) -> ( + ConnectivityConstructMeta.SloSlePolicy): + return self._yang_choices['slo-sle-policy'] + + @property + def connectivity_construct_type(self) -> ( + ConnectivityConstructMeta.ConnectivityConstructType): + return self._yang_choices['connectivity-construct-type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_monitoring/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_monitoring/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bfca50ba90e73161807ba1173e7d5113348a7581 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_monitoring/__init__.py @@ -0,0 +1,127 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ConnectivityConstructMonitoringMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: connectivity-construct-monitoring + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: connectivity-construct-monitoring + """ + + def __init__(self): + super().__init__(ConnectivityConstructMonitoring) + + def __get__(self, instance, owner=None) -> ( + 'ConnectivityConstructMonitoringMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ConnectivityConstructMonitoring': + pass + + def __enter__(self) -> 'ConnectivityConstructMonitoring': + pass + + +class ConnectivityConstructMonitoring( + YANGContainer, + metaclass=ConnectivityConstructMonitoringMeta): + """ + YANG container handler. + + YANG name: connectivity-construct-monitoring + """ + + _yang_name: Final[str] = 'connectivity-construct-monitoring' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'one-way-delay-variation': ( + one_way_delay_variation := YANGLeafMember( + 'one-way-delay-variation', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'two-way-max-delay': ( + two_way_max_delay := YANGLeafMember( + 'two-way-max-delay', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'two-way-packet-loss': ( + two_way_packet_loss := YANGLeafMember( + 'two-way-packet-loss', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'one-way-packet-loss': ( + one_way_packet_loss := YANGLeafMember( + 'one-way-packet-loss', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'one-way-max-delay': ( + one_way_max_delay := YANGLeafMember( + 'one-way-max-delay', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'two-way-delay-variation': ( + two_way_delay_variation := YANGLeafMember( + 'two-way-delay-variation', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'two-way-min-delay': ( + two_way_min_delay := YANGLeafMember( + 'two-way-min-delay', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'one-way-min-delay': ( + one_way_min_delay := YANGLeafMember( + 'one-way-min-delay', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ConnectivityConstructMonitoring': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6e1424075780ca5a04525d4124fb2af47404ec23 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/__init__.py @@ -0,0 +1,130 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ConnectivityConstructTypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: connectivity-construct-type + """ + + from .p2mp import P2mp + from .a2a import A2a + from .p2p import P2p + + class p2mp_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: p2mp + """ + + def __init__(self): + super().__init__( + ConnectivityConstructTypeMeta.P2mp) + + def __get__(self, instance, owner=None) -> ( + 'ConnectivityConstructTypeMeta.p2mp_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'ConnectivityConstructTypeMeta.P2mp'): + pass + + def __enter__(self) -> ( + 'ConnectivityConstructTypeMeta.P2mp'): + pass + + class a2a_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: a2a + """ + + def __init__(self): + super().__init__( + ConnectivityConstructTypeMeta.A2a) + + def __get__(self, instance, owner=None) -> ( + 'ConnectivityConstructTypeMeta.a2a_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'ConnectivityConstructTypeMeta.A2a'): + pass + + def __enter__(self) -> ( + 'ConnectivityConstructTypeMeta.A2a'): + pass + + class p2p_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: p2p + """ + + def __init__(self): + super().__init__( + ConnectivityConstructTypeMeta.P2p) + + def __get__(self, instance, owner=None) -> ( + 'ConnectivityConstructTypeMeta.p2p_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'ConnectivityConstructTypeMeta.P2p'): + pass + + def __enter__(self) -> ( + 'ConnectivityConstructTypeMeta.P2p'): + pass + + +class ConnectivityConstructType(YANGChoice, metaclass=ConnectivityConstructTypeMeta): + """ + YANG choice handler. + + YANG name: connectivity-construct-type + """ + + _yang_name: Final[str] = 'connectivity-construct-type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'p2mp': ( + p2mp := ( # YANGChoiceCase( + ConnectivityConstructTypeMeta. + p2mp_case_descriptor())), + + 'a2a': ( + a2a := ( # YANGChoiceCase( + ConnectivityConstructTypeMeta. + a2a_case_descriptor())), + + 'p2p': ( + p2p := ( # YANGChoiceCase( + ConnectivityConstructTypeMeta. + p2p_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1e9d402c2c675f5f6b65fc17952ad0909b8059d2 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class A2aMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: a2a + """ + from .a2a_sdp import A2aSdp + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: a2a + """ + + def __init__(self): + super().__init__(A2a) + + def __get__(self, instance, owner=None) -> ( + 'A2aMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'A2a': + pass + + def __enter__(self) -> 'A2a': + pass + + +class A2a( + YANGContainer, + metaclass=A2aMeta): + """ + YANG container handler. + + YANG name: a2a + """ + + _yang_name: Final[str] = 'a2a' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'a2a-sdp': ( + a2a_sdp := ( # YANGListMember( + A2aMeta. + A2aSdp. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'A2a': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fa176413be0dab678f83a0d9a41737c4bdd90859 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class A2aSdpMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: a2a-sdp + """ + from .slo_sle_policy import SloSlePolicy + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: a2a-sdp + """ + + def __init__(self): + super().__init__(A2aSdp) + + def __get__(self, instance, owner=None) -> ( + 'A2aSdpMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['A2aSdp']: + pass + + def __iter__(self, key) -> Iterator['A2aSdp']: + return super().__iter__() + + def __getitem__(self, key) -> 'A2aSdp': + return super()[key] + + def __enter__(self) -> ( + 'A2aSdpMeta.yang_list_descriptor'): + pass + + +class A2aSdp( + YANGListItem, + metaclass=A2aSdpMeta): + """ + YANG list item handler. + + YANG name: a2a-sdp + """ + + _yang_name: Final[str] = 'a2a-sdp' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'sdp-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sdp-id': ( + sdp_id := YANGLeafMember( + 'sdp-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'A2aSdp': + instance = super().__new__(cls) + instance._yang_choices = { + + 'slo-sle-policy': + A2aSdpMeta.SloSlePolicy( + instance), + } + return instance + + @property + def slo_sle_policy(self) -> ( + A2aSdpMeta.SloSlePolicy): + return self._yang_choices['slo-sle-policy'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b239a65e175236f7873bd8165ac2a2c423e1f448 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/__init__.py @@ -0,0 +1,101 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SloSlePolicyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: slo-sle-policy + """ + + from .standard import Standard + from .custom import Custom + + class standard_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: standard + """ + + def __init__(self): + super().__init__( + SloSlePolicyMeta.Standard) + + def __get__(self, instance, owner=None) -> ( + 'SloSlePolicyMeta.standard_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'SloSlePolicyMeta.Standard'): + pass + + def __enter__(self) -> ( + 'SloSlePolicyMeta.Standard'): + pass + + class custom_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: custom + """ + + def __init__(self): + super().__init__( + SloSlePolicyMeta.Custom) + + def __get__(self, instance, owner=None) -> ( + 'SloSlePolicyMeta.custom_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'SloSlePolicyMeta.Custom'): + pass + + def __enter__(self) -> ( + 'SloSlePolicyMeta.Custom'): + pass + + +class SloSlePolicy(YANGChoice, metaclass=SloSlePolicyMeta): + """ + YANG choice handler. + + YANG name: slo-sle-policy + """ + + _yang_name: Final[str] = 'slo-sle-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'standard': ( + standard := ( # YANGChoiceCase( + SloSlePolicyMeta. + standard_case_descriptor())), + + 'custom': ( + custom := ( # YANGChoiceCase( + SloSlePolicyMeta. + custom_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2d0c87599d2b498607615d75ec2bbaab7318af15 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class CustomMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: custom + """ + from .service_slo_sle_policy import ServiceSloSlePolicy + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: custom + """ + + def __init__(self): + super().__init__(Custom) + + def __get__(self, instance, owner=None) -> ( + 'CustomMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Custom': + pass + + def __enter__(self) -> 'Custom': + pass + + +class Custom( + YANGContainer, + metaclass=CustomMeta): + """ + YANG container handler. + + YANG name: custom + """ + + _yang_name: Final[str] = 'custom' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'service-slo-sle-policy': ( + service_slo_sle_policy := ( # YANGContainerMember( + CustomMeta. + ServiceSloSlePolicy. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Custom': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..afe092733209a8030bf14f62f3baf77eaabdd6bb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/__init__.py @@ -0,0 +1,117 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceSloSlePolicyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-slo-sle-policy + """ + from .metric_bounds import MetricBounds + from .steering_constraints import SteeringConstraints + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-slo-sle-policy + """ + + def __init__(self): + super().__init__(ServiceSloSlePolicy) + + def __get__(self, instance, owner=None) -> ( + 'ServiceSloSlePolicyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceSloSlePolicy': + pass + + def __enter__(self) -> 'ServiceSloSlePolicy': + pass + + +class ServiceSloSlePolicy( + YANGContainer, + metaclass=ServiceSloSlePolicyMeta): + """ + YANG container handler. + + YANG name: service-slo-sle-policy + """ + + _yang_name: Final[str] = 'service-slo-sle-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'policy-description': ( + policy_description := YANGLeafMember( + 'policy-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'isolation': ( + isolation := YANGLeafMember( + 'isolation', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'max-occupancy-level': ( + max_occupancy_level := YANGLeafMember( + 'max-occupancy-level', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'mtu': ( + mtu := YANGLeafMember( + 'mtu', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'metric-bounds': ( + metric_bounds := ( # YANGContainerMember( + ServiceSloSlePolicyMeta. + MetricBounds. + yang_container_descriptor())), + + 'steering-constraints': ( + steering_constraints := ( # YANGContainerMember( + ServiceSloSlePolicyMeta. + SteeringConstraints. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceSloSlePolicy': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..85730b2d943861ca804a89d0a32ab69bcc27f5c0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricBoundsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: metric-bounds + """ + from .metric_bound import MetricBound + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: metric-bounds + """ + + def __init__(self): + super().__init__(MetricBounds) + + def __get__(self, instance, owner=None) -> ( + 'MetricBoundsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'MetricBounds': + pass + + def __enter__(self) -> 'MetricBounds': + pass + + +class MetricBounds( + YANGContainer, + metaclass=MetricBoundsMeta): + """ + YANG container handler. + + YANG name: metric-bounds + """ + + _yang_name: Final[str] = 'metric-bounds' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'metric-bound': ( + metric_bound := ( # YANGListMember( + MetricBoundsMeta. + MetricBound. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MetricBounds': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..07832b8f39b43c7edd743e03c369c60d5c63624d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py @@ -0,0 +1,114 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricBoundMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: metric-bound + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: metric-bound + """ + + def __init__(self): + super().__init__(MetricBound) + + def __get__(self, instance, owner=None) -> ( + 'MetricBoundMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['MetricBound']: + pass + + def __iter__(self, key) -> Iterator['MetricBound']: + return super().__iter__() + + def __getitem__(self, key) -> 'MetricBound': + return super()[key] + + def __enter__(self) -> ( + 'MetricBoundMeta.yang_list_descriptor'): + pass + + +class MetricBound( + YANGListItem, + metaclass=MetricBoundMeta): + """ + YANG list item handler. + + YANG name: metric-bound + """ + + _yang_name: Final[str] = 'metric-bound' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'bound': ( + bound := YANGLeafMember( + 'bound', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'metric-unit': ( + metric_unit := YANGLeafMember( + 'metric-unit', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'value-description': ( + value_description := YANGLeafMember( + 'value-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MetricBound': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c308b850384ee650e0ea222b7776b52b378718fd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SteeringConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: steering-constraints + """ + from .path_constraints import PathConstraints + from .service_function import ServiceFunction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: steering-constraints + """ + + def __init__(self): + super().__init__(SteeringConstraints) + + def __get__(self, instance, owner=None) -> ( + 'SteeringConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'SteeringConstraints': + pass + + def __enter__(self) -> 'SteeringConstraints': + pass + + +class SteeringConstraints( + YANGContainer, + metaclass=SteeringConstraintsMeta): + """ + YANG container handler. + + YANG name: steering-constraints + """ + + _yang_name: Final[str] = 'steering-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-constraints': ( + path_constraints := ( # YANGContainerMember( + SteeringConstraintsMeta. + PathConstraints. + yang_container_descriptor())), + + 'service-function': ( + service_function := ( # YANGContainerMember( + SteeringConstraintsMeta. + ServiceFunction. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SteeringConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d34f1d097105a51fd50e9f351f61e915352319bd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-constraints + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-constraints + """ + + def __init__(self): + super().__init__(PathConstraints) + + def __get__(self, instance, owner=None) -> ( + 'PathConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathConstraints': + pass + + def __enter__(self) -> 'PathConstraints': + pass + + +class PathConstraints( + YANGContainer, + metaclass=PathConstraintsMeta): + """ + YANG container handler. + + YANG name: path-constraints + """ + + _yang_name: Final[str] = 'path-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2593c301f7b0b52ce5c155c0a8672714de5dae84 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-function + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-function + """ + + def __init__(self): + super().__init__(ServiceFunction) + + def __get__(self, instance, owner=None) -> ( + 'ServiceFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceFunction': + pass + + def __enter__(self) -> 'ServiceFunction': + pass + + +class ServiceFunction( + YANGContainer, + metaclass=ServiceFunctionMeta): + """ + YANG container handler. + + YANG name: service-function + """ + + _yang_name: Final[str] = 'service-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/standard/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/standard/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..46e20b7346f1d22e7a61b81a4afb170d9ed36a5b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/a2a/a2a_sdp/slo_sle_policy/standard/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class StandardMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: standard + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: standard + """ + + def __init__(self): + super().__init__(Standard) + + def __get__(self, instance, owner=None) -> ( + 'StandardMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Standard': + pass + + def __enter__(self) -> 'Standard': + pass + + +class Standard( + YANGContainer, + metaclass=StandardMeta): + """ + YANG container handler. + + YANG name: standard + """ + + _yang_name: Final[str] = 'standard' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'slo-sle-template': ( + slo_sle_template := YANGLeafMember( + 'slo-sle-template', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Standard': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/p2mp/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/p2mp/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..26189213c12a3803a76ecbcf06ff15c598e6dbce --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/p2mp/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class P2mpMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: p2mp + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: p2mp + """ + + def __init__(self): + super().__init__(P2mp) + + def __get__(self, instance, owner=None) -> ( + 'P2mpMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'P2mp': + pass + + def __enter__(self) -> 'P2mp': + pass + + +class P2mp( + YANGContainer, + metaclass=P2mpMeta): + """ + YANG container handler. + + YANG name: p2mp + """ + + _yang_name: Final[str] = 'p2mp' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'p2mp-sender-sdp': ( + p2mp_sender_sdp := YANGLeafMember( + 'p2mp-sender-sdp', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'P2mp': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/p2p/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/p2p/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5abb50263afbcf98d9fa2036fa274ba69695984f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/connectivity_construct_type/p2p/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class P2pMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: p2p + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: p2p + """ + + def __init__(self): + super().__init__(P2p) + + def __get__(self, instance, owner=None) -> ( + 'P2pMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'P2p': + pass + + def __enter__(self) -> 'P2p': + pass + + +class P2p( + YANGContainer, + metaclass=P2pMeta): + """ + YANG container handler. + + YANG name: p2p + """ + + _yang_name: Final[str] = 'p2p' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'p2p-sender-sdp': ( + p2p_sender_sdp := YANGLeafMember( + 'p2p-sender-sdp', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'p2p-receiver-sdp': ( + p2p_receiver_sdp := YANGLeafMember( + 'p2p-receiver-sdp', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'P2p': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b239a65e175236f7873bd8165ac2a2c423e1f448 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/__init__.py @@ -0,0 +1,101 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SloSlePolicyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: slo-sle-policy + """ + + from .standard import Standard + from .custom import Custom + + class standard_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: standard + """ + + def __init__(self): + super().__init__( + SloSlePolicyMeta.Standard) + + def __get__(self, instance, owner=None) -> ( + 'SloSlePolicyMeta.standard_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'SloSlePolicyMeta.Standard'): + pass + + def __enter__(self) -> ( + 'SloSlePolicyMeta.Standard'): + pass + + class custom_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: custom + """ + + def __init__(self): + super().__init__( + SloSlePolicyMeta.Custom) + + def __get__(self, instance, owner=None) -> ( + 'SloSlePolicyMeta.custom_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'SloSlePolicyMeta.Custom'): + pass + + def __enter__(self) -> ( + 'SloSlePolicyMeta.Custom'): + pass + + +class SloSlePolicy(YANGChoice, metaclass=SloSlePolicyMeta): + """ + YANG choice handler. + + YANG name: slo-sle-policy + """ + + _yang_name: Final[str] = 'slo-sle-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'standard': ( + standard := ( # YANGChoiceCase( + SloSlePolicyMeta. + standard_case_descriptor())), + + 'custom': ( + custom := ( # YANGChoiceCase( + SloSlePolicyMeta. + custom_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2d0c87599d2b498607615d75ec2bbaab7318af15 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class CustomMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: custom + """ + from .service_slo_sle_policy import ServiceSloSlePolicy + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: custom + """ + + def __init__(self): + super().__init__(Custom) + + def __get__(self, instance, owner=None) -> ( + 'CustomMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Custom': + pass + + def __enter__(self) -> 'Custom': + pass + + +class Custom( + YANGContainer, + metaclass=CustomMeta): + """ + YANG container handler. + + YANG name: custom + """ + + _yang_name: Final[str] = 'custom' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'service-slo-sle-policy': ( + service_slo_sle_policy := ( # YANGContainerMember( + CustomMeta. + ServiceSloSlePolicy. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Custom': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..afe092733209a8030bf14f62f3baf77eaabdd6bb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/__init__.py @@ -0,0 +1,117 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceSloSlePolicyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-slo-sle-policy + """ + from .metric_bounds import MetricBounds + from .steering_constraints import SteeringConstraints + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-slo-sle-policy + """ + + def __init__(self): + super().__init__(ServiceSloSlePolicy) + + def __get__(self, instance, owner=None) -> ( + 'ServiceSloSlePolicyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceSloSlePolicy': + pass + + def __enter__(self) -> 'ServiceSloSlePolicy': + pass + + +class ServiceSloSlePolicy( + YANGContainer, + metaclass=ServiceSloSlePolicyMeta): + """ + YANG container handler. + + YANG name: service-slo-sle-policy + """ + + _yang_name: Final[str] = 'service-slo-sle-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'policy-description': ( + policy_description := YANGLeafMember( + 'policy-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'isolation': ( + isolation := YANGLeafMember( + 'isolation', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'max-occupancy-level': ( + max_occupancy_level := YANGLeafMember( + 'max-occupancy-level', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'mtu': ( + mtu := YANGLeafMember( + 'mtu', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'metric-bounds': ( + metric_bounds := ( # YANGContainerMember( + ServiceSloSlePolicyMeta. + MetricBounds. + yang_container_descriptor())), + + 'steering-constraints': ( + steering_constraints := ( # YANGContainerMember( + ServiceSloSlePolicyMeta. + SteeringConstraints. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceSloSlePolicy': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..85730b2d943861ca804a89d0a32ab69bcc27f5c0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricBoundsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: metric-bounds + """ + from .metric_bound import MetricBound + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: metric-bounds + """ + + def __init__(self): + super().__init__(MetricBounds) + + def __get__(self, instance, owner=None) -> ( + 'MetricBoundsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'MetricBounds': + pass + + def __enter__(self) -> 'MetricBounds': + pass + + +class MetricBounds( + YANGContainer, + metaclass=MetricBoundsMeta): + """ + YANG container handler. + + YANG name: metric-bounds + """ + + _yang_name: Final[str] = 'metric-bounds' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'metric-bound': ( + metric_bound := ( # YANGListMember( + MetricBoundsMeta. + MetricBound. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MetricBounds': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..32ab7d60c22d534b878f967b4bf57e0509583bbb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py @@ -0,0 +1,114 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricBoundMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: metric-bound + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: metric-bound + """ + + def __init__(self): + super().__init__(MetricBound) + + def __get__(self, instance, owner=None) -> ( + 'MetricBoundMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['MetricBound']: + pass + + def __iter__(self, key) -> Iterator['MetricBound']: + return super().__iter__() + + def __getitem__(self, key) -> 'MetricBound': + return super()[key] + + def __enter__(self) -> ( + 'MetricBoundMeta.yang_list_descriptor'): + pass + + +class MetricBound( + YANGListItem, + metaclass=MetricBoundMeta): + """ + YANG list item handler. + + YANG name: metric-bound + """ + + _yang_name: Final[str] = 'metric-bound' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'value-description': ( + value_description := YANGLeafMember( + 'value-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'bound': ( + bound := YANGLeafMember( + 'bound', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'metric-unit': ( + metric_unit := YANGLeafMember( + 'metric-unit', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MetricBound': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e2c022caf902743b8abe798b61b8f1439d276862 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SteeringConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: steering-constraints + """ + from .service_function import ServiceFunction + from .path_constraints import PathConstraints + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: steering-constraints + """ + + def __init__(self): + super().__init__(SteeringConstraints) + + def __get__(self, instance, owner=None) -> ( + 'SteeringConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'SteeringConstraints': + pass + + def __enter__(self) -> 'SteeringConstraints': + pass + + +class SteeringConstraints( + YANGContainer, + metaclass=SteeringConstraintsMeta): + """ + YANG container handler. + + YANG name: steering-constraints + """ + + _yang_name: Final[str] = 'steering-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'service-function': ( + service_function := ( # YANGContainerMember( + SteeringConstraintsMeta. + ServiceFunction. + yang_container_descriptor())), + + 'path-constraints': ( + path_constraints := ( # YANGContainerMember( + SteeringConstraintsMeta. + PathConstraints. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SteeringConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d34f1d097105a51fd50e9f351f61e915352319bd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-constraints + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-constraints + """ + + def __init__(self): + super().__init__(PathConstraints) + + def __get__(self, instance, owner=None) -> ( + 'PathConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathConstraints': + pass + + def __enter__(self) -> 'PathConstraints': + pass + + +class PathConstraints( + YANGContainer, + metaclass=PathConstraintsMeta): + """ + YANG container handler. + + YANG name: path-constraints + """ + + _yang_name: Final[str] = 'path-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2593c301f7b0b52ce5c155c0a8672714de5dae84 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-function + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-function + """ + + def __init__(self): + super().__init__(ServiceFunction) + + def __get__(self, instance, owner=None) -> ( + 'ServiceFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceFunction': + pass + + def __enter__(self) -> 'ServiceFunction': + pass + + +class ServiceFunction( + YANGContainer, + metaclass=ServiceFunctionMeta): + """ + YANG container handler. + + YANG name: service-function + """ + + _yang_name: Final[str] = 'service-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/standard/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/standard/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..46e20b7346f1d22e7a61b81a4afb170d9ed36a5b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/connectivity_construct/slo_sle_policy/standard/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class StandardMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: standard + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: standard + """ + + def __init__(self): + super().__init__(Standard) + + def __get__(self, instance, owner=None) -> ( + 'StandardMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Standard': + pass + + def __enter__(self) -> 'Standard': + pass + + +class Standard( + YANGContainer, + metaclass=StandardMeta): + """ + YANG container handler. + + YANG name: standard + """ + + _yang_name: Final[str] = 'standard' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'slo-sle-template': ( + slo_sle_template := YANGLeafMember( + 'slo-sle-template', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Standard': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b239a65e175236f7873bd8165ac2a2c423e1f448 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/__init__.py @@ -0,0 +1,101 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SloSlePolicyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: slo-sle-policy + """ + + from .standard import Standard + from .custom import Custom + + class standard_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: standard + """ + + def __init__(self): + super().__init__( + SloSlePolicyMeta.Standard) + + def __get__(self, instance, owner=None) -> ( + 'SloSlePolicyMeta.standard_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'SloSlePolicyMeta.Standard'): + pass + + def __enter__(self) -> ( + 'SloSlePolicyMeta.Standard'): + pass + + class custom_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: custom + """ + + def __init__(self): + super().__init__( + SloSlePolicyMeta.Custom) + + def __get__(self, instance, owner=None) -> ( + 'SloSlePolicyMeta.custom_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'SloSlePolicyMeta.Custom'): + pass + + def __enter__(self) -> ( + 'SloSlePolicyMeta.Custom'): + pass + + +class SloSlePolicy(YANGChoice, metaclass=SloSlePolicyMeta): + """ + YANG choice handler. + + YANG name: slo-sle-policy + """ + + _yang_name: Final[str] = 'slo-sle-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'standard': ( + standard := ( # YANGChoiceCase( + SloSlePolicyMeta. + standard_case_descriptor())), + + 'custom': ( + custom := ( # YANGChoiceCase( + SloSlePolicyMeta. + custom_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2d0c87599d2b498607615d75ec2bbaab7318af15 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class CustomMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: custom + """ + from .service_slo_sle_policy import ServiceSloSlePolicy + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: custom + """ + + def __init__(self): + super().__init__(Custom) + + def __get__(self, instance, owner=None) -> ( + 'CustomMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Custom': + pass + + def __enter__(self) -> 'Custom': + pass + + +class Custom( + YANGContainer, + metaclass=CustomMeta): + """ + YANG container handler. + + YANG name: custom + """ + + _yang_name: Final[str] = 'custom' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'service-slo-sle-policy': ( + service_slo_sle_policy := ( # YANGContainerMember( + CustomMeta. + ServiceSloSlePolicy. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Custom': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ea6d366eb1ff15535bea20dc431827e5f859bc4f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/__init__.py @@ -0,0 +1,117 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceSloSlePolicyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-slo-sle-policy + """ + from .steering_constraints import SteeringConstraints + from .metric_bounds import MetricBounds + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-slo-sle-policy + """ + + def __init__(self): + super().__init__(ServiceSloSlePolicy) + + def __get__(self, instance, owner=None) -> ( + 'ServiceSloSlePolicyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceSloSlePolicy': + pass + + def __enter__(self) -> 'ServiceSloSlePolicy': + pass + + +class ServiceSloSlePolicy( + YANGContainer, + metaclass=ServiceSloSlePolicyMeta): + """ + YANG container handler. + + YANG name: service-slo-sle-policy + """ + + _yang_name: Final[str] = 'service-slo-sle-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'isolation': ( + isolation := YANGLeafMember( + 'isolation', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'mtu': ( + mtu := YANGLeafMember( + 'mtu', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'max-occupancy-level': ( + max_occupancy_level := YANGLeafMember( + 'max-occupancy-level', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'policy-description': ( + policy_description := YANGLeafMember( + 'policy-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'steering-constraints': ( + steering_constraints := ( # YANGContainerMember( + ServiceSloSlePolicyMeta. + SteeringConstraints. + yang_container_descriptor())), + + 'metric-bounds': ( + metric_bounds := ( # YANGContainerMember( + ServiceSloSlePolicyMeta. + MetricBounds. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceSloSlePolicy': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..85730b2d943861ca804a89d0a32ab69bcc27f5c0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricBoundsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: metric-bounds + """ + from .metric_bound import MetricBound + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: metric-bounds + """ + + def __init__(self): + super().__init__(MetricBounds) + + def __get__(self, instance, owner=None) -> ( + 'MetricBoundsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'MetricBounds': + pass + + def __enter__(self) -> 'MetricBounds': + pass + + +class MetricBounds( + YANGContainer, + metaclass=MetricBoundsMeta): + """ + YANG container handler. + + YANG name: metric-bounds + """ + + _yang_name: Final[str] = 'metric-bounds' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'metric-bound': ( + metric_bound := ( # YANGListMember( + MetricBoundsMeta. + MetricBound. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MetricBounds': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..23374967999723000d8649da5d3ec8d5489a5794 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py @@ -0,0 +1,114 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricBoundMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: metric-bound + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: metric-bound + """ + + def __init__(self): + super().__init__(MetricBound) + + def __get__(self, instance, owner=None) -> ( + 'MetricBoundMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['MetricBound']: + pass + + def __iter__(self, key) -> Iterator['MetricBound']: + return super().__iter__() + + def __getitem__(self, key) -> 'MetricBound': + return super()[key] + + def __enter__(self) -> ( + 'MetricBoundMeta.yang_list_descriptor'): + pass + + +class MetricBound( + YANGListItem, + metaclass=MetricBoundMeta): + """ + YANG list item handler. + + YANG name: metric-bound + """ + + _yang_name: Final[str] = 'metric-bound' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'value-description': ( + value_description := YANGLeafMember( + 'value-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'bound': ( + bound := YANGLeafMember( + 'bound', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'metric-unit': ( + metric_unit := YANGLeafMember( + 'metric-unit', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MetricBound': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e2c022caf902743b8abe798b61b8f1439d276862 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SteeringConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: steering-constraints + """ + from .service_function import ServiceFunction + from .path_constraints import PathConstraints + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: steering-constraints + """ + + def __init__(self): + super().__init__(SteeringConstraints) + + def __get__(self, instance, owner=None) -> ( + 'SteeringConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'SteeringConstraints': + pass + + def __enter__(self) -> 'SteeringConstraints': + pass + + +class SteeringConstraints( + YANGContainer, + metaclass=SteeringConstraintsMeta): + """ + YANG container handler. + + YANG name: steering-constraints + """ + + _yang_name: Final[str] = 'steering-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'service-function': ( + service_function := ( # YANGContainerMember( + SteeringConstraintsMeta. + ServiceFunction. + yang_container_descriptor())), + + 'path-constraints': ( + path_constraints := ( # YANGContainerMember( + SteeringConstraintsMeta. + PathConstraints. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SteeringConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d34f1d097105a51fd50e9f351f61e915352319bd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-constraints + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-constraints + """ + + def __init__(self): + super().__init__(PathConstraints) + + def __get__(self, instance, owner=None) -> ( + 'PathConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathConstraints': + pass + + def __enter__(self) -> 'PathConstraints': + pass + + +class PathConstraints( + YANGContainer, + metaclass=PathConstraintsMeta): + """ + YANG container handler. + + YANG name: path-constraints + """ + + _yang_name: Final[str] = 'path-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2593c301f7b0b52ce5c155c0a8672714de5dae84 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-function + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-function + """ + + def __init__(self): + super().__init__(ServiceFunction) + + def __get__(self, instance, owner=None) -> ( + 'ServiceFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceFunction': + pass + + def __enter__(self) -> 'ServiceFunction': + pass + + +class ServiceFunction( + YANGContainer, + metaclass=ServiceFunctionMeta): + """ + YANG container handler. + + YANG name: service-function + """ + + _yang_name: Final[str] = 'service-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/standard/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/standard/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..46e20b7346f1d22e7a61b81a4afb170d9ed36a5b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/connection_groups/connection_group/slo_sle_policy/standard/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class StandardMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: standard + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: standard + """ + + def __init__(self): + super().__init__(Standard) + + def __get__(self, instance, owner=None) -> ( + 'StandardMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Standard': + pass + + def __enter__(self) -> 'Standard': + pass + + +class Standard( + YANGContainer, + metaclass=StandardMeta): + """ + YANG container handler. + + YANG name: standard + """ + + _yang_name: Final[str] = 'standard' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'slo-sle-template': ( + slo_sle_template := YANGLeafMember( + 'slo-sle-template', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Standard': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3239d57811ab3ddff018c0347524513d77934aa --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SdpsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: sdps + """ + from .sdp import Sdp + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: sdps + """ + + def __init__(self): + super().__init__(Sdps) + + def __get__(self, instance, owner=None) -> ( + 'SdpsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Sdps': + pass + + def __enter__(self) -> 'Sdps': + pass + + +class Sdps( + YANGContainer, + metaclass=SdpsMeta): + """ + YANG container handler. + + YANG name: sdps + """ + + _yang_name: Final[str] = 'sdps' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'sdp': ( + sdp := ( # YANGListMember( + SdpsMeta. + Sdp. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Sdps': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5fc0ff62c3ed5a5ea1a7d64e77edeb84d3edf286 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/__init__.py @@ -0,0 +1,182 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SdpMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: sdp + """ + from .sdp_monitoring import SdpMonitoring + from .outgoing_qos_policy import OutgoingQosPolicy + from .service_match_criteria import ServiceMatchCriteria + from .sdp_peering import SdpPeering + from .status import Status + from .attachment_circuits import AttachmentCircuits + from .location import Location + from .incoming_qos_policy import IncomingQosPolicy + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: sdp + """ + + def __init__(self): + super().__init__(Sdp) + + def __get__(self, instance, owner=None) -> ( + 'SdpMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Sdp']: + pass + + def __iter__(self, key) -> Iterator['Sdp']: + return super().__iter__() + + def __getitem__(self, key) -> 'Sdp': + return super()[key] + + def __enter__(self) -> ( + 'SdpMeta.yang_list_descriptor'): + pass + + +class Sdp( + YANGListItem, + metaclass=SdpMeta): + """ + YANG list item handler. + + YANG name: sdp + """ + + _yang_name: Final[str] = 'sdp' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'sdp-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sdp-id': ( + sdp_id := YANGLeafMember( + 'sdp-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'peer-sap-id': ( + peer_sap_id := YANGLeafMember( + 'peer-sap-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'sdp-description': ( + sdp_description := YANGLeafMember( + 'sdp-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'sdp-ip': ( + sdp_ip := YANGLeafMember( + 'sdp-ip', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'ltp': ( + ltp := YANGLeafMember( + 'ltp', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'sdp-monitoring': ( + sdp_monitoring := ( # YANGContainerMember( + SdpMeta. + SdpMonitoring. + yang_container_descriptor())), + + 'outgoing-qos-policy': ( + outgoing_qos_policy := ( # YANGContainerMember( + SdpMeta. + OutgoingQosPolicy. + yang_container_descriptor())), + + 'service-match-criteria': ( + service_match_criteria := ( # YANGContainerMember( + SdpMeta. + ServiceMatchCriteria. + yang_container_descriptor())), + + 'sdp-peering': ( + sdp_peering := ( # YANGContainerMember( + SdpMeta. + SdpPeering. + yang_container_descriptor())), + + 'status': ( + status := ( # YANGContainerMember( + SdpMeta. + Status. + yang_container_descriptor())), + + 'attachment-circuits': ( + attachment_circuits := ( # YANGContainerMember( + SdpMeta. + AttachmentCircuits. + yang_container_descriptor())), + + 'location': ( + location := ( # YANGContainerMember( + SdpMeta. + Location. + yang_container_descriptor())), + + 'incoming-qos-policy': ( + incoming_qos_policy := ( # YANGContainerMember( + SdpMeta. + IncomingQosPolicy. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Sdp': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..624b09988064151b30cfd5286a6a0ef6681e3dd0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AttachmentCircuitsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: attachment-circuits + """ + from .attachment_circuit import AttachmentCircuit + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: attachment-circuits + """ + + def __init__(self): + super().__init__(AttachmentCircuits) + + def __get__(self, instance, owner=None) -> ( + 'AttachmentCircuitsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AttachmentCircuits': + pass + + def __enter__(self) -> 'AttachmentCircuits': + pass + + +class AttachmentCircuits( + YANGContainer, + metaclass=AttachmentCircuitsMeta): + """ + YANG container handler. + + YANG name: attachment-circuits + """ + + _yang_name: Final[str] = 'attachment-circuits' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'attachment-circuit': ( + attachment_circuit := ( # YANGListMember( + AttachmentCircuitsMeta. + AttachmentCircuit. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AttachmentCircuits': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..93194779e9c37ccae0bca5adcb51ccfb0ff7c349 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/__init__.py @@ -0,0 +1,166 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AttachmentCircuitMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: attachment-circuit + """ + from .ac_tags import AcTags + from .outgoing_qos_policy import OutgoingQosPolicy + from .incoming_qos_policy import IncomingQosPolicy + from .sdp_peering import SdpPeering + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: attachment-circuit + """ + + def __init__(self): + super().__init__(AttachmentCircuit) + + def __get__(self, instance, owner=None) -> ( + 'AttachmentCircuitMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AttachmentCircuit']: + pass + + def __iter__(self, key) -> Iterator['AttachmentCircuit']: + return super().__iter__() + + def __getitem__(self, key) -> 'AttachmentCircuit': + return super()[key] + + def __enter__(self) -> ( + 'AttachmentCircuitMeta.yang_list_descriptor'): + pass + + +class AttachmentCircuit( + YANGListItem, + metaclass=AttachmentCircuitMeta): + """ + YANG list item handler. + + YANG name: attachment-circuit + """ + + _yang_name: Final[str] = 'attachment-circuit' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'ac-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'ac-node-id': ( + ac_node_id := YANGLeafMember( + 'ac-node-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'ac-tp-id': ( + ac_tp_id := YANGLeafMember( + 'ac-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'ac-ip-prefix-length': ( + ac_ip_prefix_length := YANGLeafMember( + 'ac-ip-prefix-length', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'ac-ip-address': ( + ac_ip_address := YANGLeafMember( + 'ac-ip-address', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'mtu': ( + mtu := YANGLeafMember( + 'mtu', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'ac-description': ( + ac_description := YANGLeafMember( + 'ac-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'ac-id': ( + ac_id := YANGLeafMember( + 'ac-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'peer-sap-id': ( + peer_sap_id := YANGLeafMember( + 'peer-sap-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'ac-tags': ( + ac_tags := ( # YANGContainerMember( + AttachmentCircuitMeta. + AcTags. + yang_container_descriptor())), + + 'outgoing-qos-policy': ( + outgoing_qos_policy := ( # YANGContainerMember( + AttachmentCircuitMeta. + OutgoingQosPolicy. + yang_container_descriptor())), + + 'incoming-qos-policy': ( + incoming_qos_policy := ( # YANGContainerMember( + AttachmentCircuitMeta. + IncomingQosPolicy. + yang_container_descriptor())), + + 'sdp-peering': ( + sdp_peering := ( # YANGContainerMember( + AttachmentCircuitMeta. + SdpPeering. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AttachmentCircuit': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/ac_tags/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/ac_tags/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a18ad45c114040f6b3d58ff592ea6cfd9461a8ef --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/ac_tags/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AcTagsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: ac-tags + """ + from .ac_tags import AcTags + from .ac_tag_opaque import AcTagOpaque + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: ac-tags + """ + + def __init__(self): + super().__init__(AcTags) + + def __get__(self, instance, owner=None) -> ( + 'AcTagsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AcTags': + pass + + def __enter__(self) -> 'AcTags': + pass + + +class AcTags( + YANGContainer, + metaclass=AcTagsMeta): + """ + YANG container handler. + + YANG name: ac-tags + """ + + _yang_name: Final[str] = 'ac-tags' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'ac-tags': ( + ac_tags := ( # YANGListMember( + AcTagsMeta. + AcTags. + yang_list_descriptor())), + + 'ac-tag-opaque': ( + ac_tag_opaque := ( # YANGListMember( + AcTagsMeta. + AcTagOpaque. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AcTags': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/ac_tags/ac_tag_opaque/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/ac_tags/ac_tag_opaque/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d56e829739daeecc91ead77fb6e40c954532a15e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/ac_tags/ac_tag_opaque/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AcTagOpaqueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: ac-tag-opaque + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: ac-tag-opaque + """ + + def __init__(self): + super().__init__(AcTagOpaque) + + def __get__(self, instance, owner=None) -> ( + 'AcTagOpaqueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AcTagOpaque']: + pass + + def __iter__(self, key) -> Iterator['AcTagOpaque']: + return super().__iter__() + + def __getitem__(self, key) -> 'AcTagOpaque': + return super()[key] + + def __enter__(self) -> ( + 'AcTagOpaqueMeta.yang_list_descriptor'): + pass + + +class AcTagOpaque( + YANGListItem, + metaclass=AcTagOpaqueMeta): + """ + YANG list item handler. + + YANG name: ac-tag-opaque + """ + + _yang_name: Final[str] = 'ac-tag-opaque' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tag-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tag-name': ( + tag_name := YANGLeafMember( + 'tag-name', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AcTagOpaque': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/ac_tags/ac_tags/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/ac_tags/ac_tags/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8ef753261d2bf1b99a0fd2a2cf198785baffff1e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/ac_tags/ac_tags/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AcTagsMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: ac-tags + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: ac-tags + """ + + def __init__(self): + super().__init__(AcTags) + + def __get__(self, instance, owner=None) -> ( + 'AcTagsMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AcTags']: + pass + + def __iter__(self, key) -> Iterator['AcTags']: + return super().__iter__() + + def __getitem__(self, key) -> 'AcTags': + return super()[key] + + def __enter__(self) -> ( + 'AcTagsMeta.yang_list_descriptor'): + pass + + +class AcTags( + YANGListItem, + metaclass=AcTagsMeta): + """ + YANG list item handler. + + YANG name: ac-tags + """ + + _yang_name: Final[str] = 'ac-tags' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'ac-tag-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'ac-tag-type': ( + ac_tag_type := YANGLeafMember( + 'ac-tag-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AcTags': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/incoming_qos_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/incoming_qos_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..abad77461c9f94149dc016054d669526c83570af --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/incoming_qos_policy/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class IncomingQosPolicyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: incoming-qos-policy + """ + from .rate_limits import RateLimits + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: incoming-qos-policy + """ + + def __init__(self): + super().__init__(IncomingQosPolicy) + + def __get__(self, instance, owner=None) -> ( + 'IncomingQosPolicyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'IncomingQosPolicy': + pass + + def __enter__(self) -> 'IncomingQosPolicy': + pass + + +class IncomingQosPolicy( + YANGContainer, + metaclass=IncomingQosPolicyMeta): + """ + YANG container handler. + + YANG name: incoming-qos-policy + """ + + _yang_name: Final[str] = 'incoming-qos-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'qos-policy-name': ( + qos_policy_name := YANGLeafMember( + 'qos-policy-name', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'rate-limits': ( + rate_limits := ( # YANGContainerMember( + IncomingQosPolicyMeta. + RateLimits. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'IncomingQosPolicy': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/incoming_qos_policy/rate_limits/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/incoming_qos_policy/rate_limits/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..492759055bf57b40705a54dfd087f89fa61a87dc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/incoming_qos_policy/rate_limits/__init__.py @@ -0,0 +1,115 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RateLimitsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: rate-limits + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: rate-limits + """ + + def __init__(self): + super().__init__(RateLimits) + + def __get__(self, instance, owner=None) -> ( + 'RateLimitsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'RateLimits': + pass + + def __enter__(self) -> 'RateLimits': + pass + + +class RateLimits( + YANGContainer, + metaclass=RateLimitsMeta): + """ + YANG container handler. + + YANG name: rate-limits + """ + + _yang_name: Final[str] = 'rate-limits' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'cir': ( + cir := YANGLeafMember( + 'cir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'cbs': ( + cbs := YANGLeafMember( + 'cbs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'pir': ( + pir := YANGLeafMember( + 'pir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'pbs': ( + pbs := YANGLeafMember( + 'pbs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'eir': ( + eir := YANGLeafMember( + 'eir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'ebs': ( + ebs := YANGLeafMember( + 'ebs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RateLimits': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/outgoing_qos_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/outgoing_qos_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..893cb264eba6e98af718d8244d262d0888793ca0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/outgoing_qos_policy/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OutgoingQosPolicyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: outgoing-qos-policy + """ + from .rate_limits import RateLimits + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: outgoing-qos-policy + """ + + def __init__(self): + super().__init__(OutgoingQosPolicy) + + def __get__(self, instance, owner=None) -> ( + 'OutgoingQosPolicyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'OutgoingQosPolicy': + pass + + def __enter__(self) -> 'OutgoingQosPolicy': + pass + + +class OutgoingQosPolicy( + YANGContainer, + metaclass=OutgoingQosPolicyMeta): + """ + YANG container handler. + + YANG name: outgoing-qos-policy + """ + + _yang_name: Final[str] = 'outgoing-qos-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'qos-policy-name': ( + qos_policy_name := YANGLeafMember( + 'qos-policy-name', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'rate-limits': ( + rate_limits := ( # YANGContainerMember( + OutgoingQosPolicyMeta. + RateLimits. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'OutgoingQosPolicy': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/outgoing_qos_policy/rate_limits/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/outgoing_qos_policy/rate_limits/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..445a7a5df5d7db2b92ecb59f0f54a4c316328d78 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/outgoing_qos_policy/rate_limits/__init__.py @@ -0,0 +1,115 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RateLimitsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: rate-limits + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: rate-limits + """ + + def __init__(self): + super().__init__(RateLimits) + + def __get__(self, instance, owner=None) -> ( + 'RateLimitsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'RateLimits': + pass + + def __enter__(self) -> 'RateLimits': + pass + + +class RateLimits( + YANGContainer, + metaclass=RateLimitsMeta): + """ + YANG container handler. + + YANG name: rate-limits + """ + + _yang_name: Final[str] = 'rate-limits' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'cbs': ( + cbs := YANGLeafMember( + 'cbs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'ebs': ( + ebs := YANGLeafMember( + 'ebs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'pbs': ( + pbs := YANGLeafMember( + 'pbs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'cir': ( + cir := YANGLeafMember( + 'cir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'pir': ( + pir := YANGLeafMember( + 'pir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'eir': ( + eir := YANGLeafMember( + 'eir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RateLimits': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c7b5e10b24076aa3928995dc846b4e138516379b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SdpPeeringMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: sdp-peering + """ + from .opaque import Opaque + from .protocol import Protocol + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: sdp-peering + """ + + def __init__(self): + super().__init__(SdpPeering) + + def __get__(self, instance, owner=None) -> ( + 'SdpPeeringMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'SdpPeering': + pass + + def __enter__(self) -> 'SdpPeering': + pass + + +class SdpPeering( + YANGContainer, + metaclass=SdpPeeringMeta): + """ + YANG container handler. + + YANG name: sdp-peering + """ + + _yang_name: Final[str] = 'sdp-peering' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'opaque': ( + opaque := ( # YANGListMember( + SdpPeeringMeta. + Opaque. + yang_list_descriptor())), + + 'protocol': ( + protocol := ( # YANGListMember( + SdpPeeringMeta. + Protocol. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SdpPeering': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/opaque/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/opaque/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b367227c3d43cd31c1b3df857ed944d62d371806 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/opaque/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OpaqueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: opaque + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: opaque + """ + + def __init__(self): + super().__init__(Opaque) + + def __get__(self, instance, owner=None) -> ( + 'OpaqueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Opaque']: + pass + + def __iter__(self, key) -> Iterator['Opaque']: + return super().__iter__() + + def __getitem__(self, key) -> 'Opaque': + return super()[key] + + def __enter__(self) -> ( + 'OpaqueMeta.yang_list_descriptor'): + pass + + +class Opaque( + YANGListItem, + metaclass=OpaqueMeta): + """ + YANG list item handler. + + YANG name: opaque + """ + + _yang_name: Final[str] = 'opaque' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'attribute-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'attribute-name': ( + attribute_name := YANGLeafMember( + 'attribute-name', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Opaque': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/protocol/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/protocol/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..850f7d924c02b4a89030c1a7757b1e728ad35326 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/protocol/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ProtocolMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: protocol + """ + from .attribute import Attribute + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: protocol + """ + + def __init__(self): + super().__init__(Protocol) + + def __get__(self, instance, owner=None) -> ( + 'ProtocolMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Protocol']: + pass + + def __iter__(self, key) -> Iterator['Protocol']: + return super().__iter__() + + def __getitem__(self, key) -> 'Protocol': + return super()[key] + + def __enter__(self) -> ( + 'ProtocolMeta.yang_list_descriptor'): + pass + + +class Protocol( + YANGListItem, + metaclass=ProtocolMeta): + """ + YANG list item handler. + + YANG name: protocol + """ + + _yang_name: Final[str] = 'protocol' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'protocol-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'protocol-type': ( + protocol_type := YANGLeafMember( + 'protocol-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'attribute': ( + attribute := ( # YANGListMember( + ProtocolMeta. + Attribute. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Protocol': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/protocol/attribute/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/protocol/attribute/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..76180637c83f2a158838bacaae99add6e9fe5b61 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/attachment_circuits/attachment_circuit/sdp_peering/protocol/attribute/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AttributeMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: attribute + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: attribute + """ + + def __init__(self): + super().__init__(Attribute) + + def __get__(self, instance, owner=None) -> ( + 'AttributeMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Attribute']: + pass + + def __iter__(self, key) -> Iterator['Attribute']: + return super().__iter__() + + def __getitem__(self, key) -> 'Attribute': + return super()[key] + + def __enter__(self) -> ( + 'AttributeMeta.yang_list_descriptor'): + pass + + +class Attribute( + YANGListItem, + metaclass=AttributeMeta): + """ + YANG list item handler. + + YANG name: attribute + """ + + _yang_name: Final[str] = 'attribute' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'attribute-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'attribute-type': ( + attribute_type := YANGLeafMember( + 'attribute-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Attribute': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/incoming_qos_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/incoming_qos_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..abad77461c9f94149dc016054d669526c83570af --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/incoming_qos_policy/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class IncomingQosPolicyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: incoming-qos-policy + """ + from .rate_limits import RateLimits + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: incoming-qos-policy + """ + + def __init__(self): + super().__init__(IncomingQosPolicy) + + def __get__(self, instance, owner=None) -> ( + 'IncomingQosPolicyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'IncomingQosPolicy': + pass + + def __enter__(self) -> 'IncomingQosPolicy': + pass + + +class IncomingQosPolicy( + YANGContainer, + metaclass=IncomingQosPolicyMeta): + """ + YANG container handler. + + YANG name: incoming-qos-policy + """ + + _yang_name: Final[str] = 'incoming-qos-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'qos-policy-name': ( + qos_policy_name := YANGLeafMember( + 'qos-policy-name', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'rate-limits': ( + rate_limits := ( # YANGContainerMember( + IncomingQosPolicyMeta. + RateLimits. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'IncomingQosPolicy': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/incoming_qos_policy/rate_limits/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/incoming_qos_policy/rate_limits/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..49a7b3deeb46fce3abf89af50e4e3b922a00bcc5 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/incoming_qos_policy/rate_limits/__init__.py @@ -0,0 +1,115 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RateLimitsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: rate-limits + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: rate-limits + """ + + def __init__(self): + super().__init__(RateLimits) + + def __get__(self, instance, owner=None) -> ( + 'RateLimitsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'RateLimits': + pass + + def __enter__(self) -> 'RateLimits': + pass + + +class RateLimits( + YANGContainer, + metaclass=RateLimitsMeta): + """ + YANG container handler. + + YANG name: rate-limits + """ + + _yang_name: Final[str] = 'rate-limits' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'cbs': ( + cbs := YANGLeafMember( + 'cbs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'eir': ( + eir := YANGLeafMember( + 'eir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'pir': ( + pir := YANGLeafMember( + 'pir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'pbs': ( + pbs := YANGLeafMember( + 'pbs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'cir': ( + cir := YANGLeafMember( + 'cir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'ebs': ( + ebs := YANGLeafMember( + 'ebs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RateLimits': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/location/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/location/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a88123d6c81ab2c15db96d13ffa2af9458fa904e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/location/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LocationMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: location + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: location + """ + + def __init__(self): + super().__init__(Location) + + def __get__(self, instance, owner=None) -> ( + 'LocationMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Location': + pass + + def __enter__(self) -> 'Location': + pass + + +class Location( + YANGContainer, + metaclass=LocationMeta): + """ + YANG container handler. + + YANG name: location + """ + + _yang_name: Final[str] = 'location' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'altitude': ( + altitude := YANGLeafMember( + 'altitude', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'latitude': ( + latitude := YANGLeafMember( + 'latitude', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'longitude': ( + longitude := YANGLeafMember( + 'longitude', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Location': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/outgoing_qos_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/outgoing_qos_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..893cb264eba6e98af718d8244d262d0888793ca0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/outgoing_qos_policy/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OutgoingQosPolicyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: outgoing-qos-policy + """ + from .rate_limits import RateLimits + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: outgoing-qos-policy + """ + + def __init__(self): + super().__init__(OutgoingQosPolicy) + + def __get__(self, instance, owner=None) -> ( + 'OutgoingQosPolicyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'OutgoingQosPolicy': + pass + + def __enter__(self) -> 'OutgoingQosPolicy': + pass + + +class OutgoingQosPolicy( + YANGContainer, + metaclass=OutgoingQosPolicyMeta): + """ + YANG container handler. + + YANG name: outgoing-qos-policy + """ + + _yang_name: Final[str] = 'outgoing-qos-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'qos-policy-name': ( + qos_policy_name := YANGLeafMember( + 'qos-policy-name', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'rate-limits': ( + rate_limits := ( # YANGContainerMember( + OutgoingQosPolicyMeta. + RateLimits. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'OutgoingQosPolicy': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/outgoing_qos_policy/rate_limits/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/outgoing_qos_policy/rate_limits/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fdf96f15c5ceeb7ae878052b998c9658202e04d0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/outgoing_qos_policy/rate_limits/__init__.py @@ -0,0 +1,115 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RateLimitsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: rate-limits + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: rate-limits + """ + + def __init__(self): + super().__init__(RateLimits) + + def __get__(self, instance, owner=None) -> ( + 'RateLimitsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'RateLimits': + pass + + def __enter__(self) -> 'RateLimits': + pass + + +class RateLimits( + YANGContainer, + metaclass=RateLimitsMeta): + """ + YANG container handler. + + YANG name: rate-limits + """ + + _yang_name: Final[str] = 'rate-limits' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'eir': ( + eir := YANGLeafMember( + 'eir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'cir': ( + cir := YANGLeafMember( + 'cir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'pir': ( + pir := YANGLeafMember( + 'pir', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'pbs': ( + pbs := YANGLeafMember( + 'pbs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'cbs': ( + cbs := YANGLeafMember( + 'cbs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'ebs': ( + ebs := YANGLeafMember( + 'ebs', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RateLimits': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_monitoring/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_monitoring/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a65f09fc30c0324738fdabb36a717bcfddf3496e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_monitoring/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SdpMonitoringMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: sdp-monitoring + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: sdp-monitoring + """ + + def __init__(self): + super().__init__(SdpMonitoring) + + def __get__(self, instance, owner=None) -> ( + 'SdpMonitoringMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'SdpMonitoring': + pass + + def __enter__(self) -> 'SdpMonitoring': + pass + + +class SdpMonitoring( + YANGContainer, + metaclass=SdpMonitoringMeta): + """ + YANG container handler. + + YANG name: sdp-monitoring + """ + + _yang_name: Final[str] = 'sdp-monitoring' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'incoming-utilized-bandwidth': ( + incoming_utilized_bandwidth := YANGLeafMember( + 'incoming-utilized-bandwidth', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'incoming-bw-utilization': ( + incoming_bw_utilization := YANGLeafMember( + 'incoming-bw-utilization', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'outgoing-bw-utilization': ( + outgoing_bw_utilization := YANGLeafMember( + 'outgoing-bw-utilization', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'outgoing-utilized-bandwidth': ( + outgoing_utilized_bandwidth := YANGLeafMember( + 'outgoing-utilized-bandwidth', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SdpMonitoring': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d745437bd534e2fa460f16fb2ca3bb982d4ce3fc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SdpPeeringMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: sdp-peering + """ + from .protocol import Protocol + from .opaque import Opaque + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: sdp-peering + """ + + def __init__(self): + super().__init__(SdpPeering) + + def __get__(self, instance, owner=None) -> ( + 'SdpPeeringMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'SdpPeering': + pass + + def __enter__(self) -> 'SdpPeering': + pass + + +class SdpPeering( + YANGContainer, + metaclass=SdpPeeringMeta): + """ + YANG container handler. + + YANG name: sdp-peering + """ + + _yang_name: Final[str] = 'sdp-peering' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'protocol': ( + protocol := ( # YANGListMember( + SdpPeeringMeta. + Protocol. + yang_list_descriptor())), + + 'opaque': ( + opaque := ( # YANGListMember( + SdpPeeringMeta. + Opaque. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SdpPeering': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/opaque/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/opaque/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b367227c3d43cd31c1b3df857ed944d62d371806 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/opaque/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OpaqueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: opaque + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: opaque + """ + + def __init__(self): + super().__init__(Opaque) + + def __get__(self, instance, owner=None) -> ( + 'OpaqueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Opaque']: + pass + + def __iter__(self, key) -> Iterator['Opaque']: + return super().__iter__() + + def __getitem__(self, key) -> 'Opaque': + return super()[key] + + def __enter__(self) -> ( + 'OpaqueMeta.yang_list_descriptor'): + pass + + +class Opaque( + YANGListItem, + metaclass=OpaqueMeta): + """ + YANG list item handler. + + YANG name: opaque + """ + + _yang_name: Final[str] = 'opaque' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'attribute-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'attribute-name': ( + attribute_name := YANGLeafMember( + 'attribute-name', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Opaque': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/protocol/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/protocol/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..850f7d924c02b4a89030c1a7757b1e728ad35326 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/protocol/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ProtocolMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: protocol + """ + from .attribute import Attribute + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: protocol + """ + + def __init__(self): + super().__init__(Protocol) + + def __get__(self, instance, owner=None) -> ( + 'ProtocolMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Protocol']: + pass + + def __iter__(self, key) -> Iterator['Protocol']: + return super().__iter__() + + def __getitem__(self, key) -> 'Protocol': + return super()[key] + + def __enter__(self) -> ( + 'ProtocolMeta.yang_list_descriptor'): + pass + + +class Protocol( + YANGListItem, + metaclass=ProtocolMeta): + """ + YANG list item handler. + + YANG name: protocol + """ + + _yang_name: Final[str] = 'protocol' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'protocol-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'protocol-type': ( + protocol_type := YANGLeafMember( + 'protocol-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'attribute': ( + attribute := ( # YANGListMember( + ProtocolMeta. + Attribute. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Protocol': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/protocol/attribute/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/protocol/attribute/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..76180637c83f2a158838bacaae99add6e9fe5b61 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/sdp_peering/protocol/attribute/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AttributeMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: attribute + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: attribute + """ + + def __init__(self): + super().__init__(Attribute) + + def __get__(self, instance, owner=None) -> ( + 'AttributeMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Attribute']: + pass + + def __iter__(self, key) -> Iterator['Attribute']: + return super().__iter__() + + def __getitem__(self, key) -> 'Attribute': + return super()[key] + + def __enter__(self) -> ( + 'AttributeMeta.yang_list_descriptor'): + pass + + +class Attribute( + YANGListItem, + metaclass=AttributeMeta): + """ + YANG list item handler. + + YANG name: attribute + """ + + _yang_name: Final[str] = 'attribute' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'attribute-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'attribute-type': ( + attribute_type := YANGLeafMember( + 'attribute-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Attribute': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/service_match_criteria/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/service_match_criteria/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f39dc9971795fd83eb61a09ca7a4fea42352ac18 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/service_match_criteria/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceMatchCriteriaMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-match-criteria + """ + from .match_criterion import MatchCriterion + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-match-criteria + """ + + def __init__(self): + super().__init__(ServiceMatchCriteria) + + def __get__(self, instance, owner=None) -> ( + 'ServiceMatchCriteriaMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceMatchCriteria': + pass + + def __enter__(self) -> 'ServiceMatchCriteria': + pass + + +class ServiceMatchCriteria( + YANGContainer, + metaclass=ServiceMatchCriteriaMeta): + """ + YANG container handler. + + YANG name: service-match-criteria + """ + + _yang_name: Final[str] = 'service-match-criteria' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'match-criterion': ( + match_criterion := ( # YANGListMember( + ServiceMatchCriteriaMeta. + MatchCriterion. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceMatchCriteria': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/service_match_criteria/match_criterion/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/service_match_criteria/match_criterion/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..99d87b7934889ec3665b1e4af12f836ec76016e0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/service_match_criteria/match_criterion/__init__.py @@ -0,0 +1,120 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MatchCriterionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: match-criterion + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: match-criterion + """ + + def __init__(self): + super().__init__(MatchCriterion) + + def __get__(self, instance, owner=None) -> ( + 'MatchCriterionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['MatchCriterion']: + pass + + def __iter__(self, key) -> Iterator['MatchCriterion']: + return super().__iter__() + + def __getitem__(self, key) -> 'MatchCriterion': + return super()[key] + + def __enter__(self) -> ( + 'MatchCriterionMeta.yang_list_descriptor'): + pass + + +class MatchCriterion( + YANGListItem, + metaclass=MatchCriterionMeta): + """ + YANG list item handler. + + YANG name: match-criterion + """ + + _yang_name: Final[str] = 'match-criterion' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'connection-group-sdp-role': ( + connection_group_sdp_role := YANGLeafMember( + 'connection-group-sdp-role', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'target-connection-group-id': ( + target_connection_group_id := YANGLeafMember( + 'target-connection-group-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'target-connectivity-construct-id': ( + target_connectivity_construct_id := YANGLeafMember( + 'target-connectivity-construct-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'match-type': ( + match_type := YANGLeafMember( + 'match-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MatchCriterion': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/status/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/status/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f802183296df337e7ebacca0d3290f433341130d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/status/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class StatusMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: status + """ + from .oper_status import OperStatus + from .admin_status import AdminStatus + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: status + """ + + def __init__(self): + super().__init__(Status) + + def __get__(self, instance, owner=None) -> ( + 'StatusMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Status': + pass + + def __enter__(self) -> 'Status': + pass + + +class Status( + YANGContainer, + metaclass=StatusMeta): + """ + YANG container handler. + + YANG name: status + """ + + _yang_name: Final[str] = 'status' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'oper-status': ( + oper_status := ( # YANGContainerMember( + StatusMeta. + OperStatus. + yang_container_descriptor())), + + 'admin-status': ( + admin_status := ( # YANGContainerMember( + StatusMeta. + AdminStatus. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Status': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/status/admin_status/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/status/admin_status/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f5581ef12dac29ce3050652c8c969a76f0ac88fb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/status/admin_status/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AdminStatusMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: admin-status + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: admin-status + """ + + def __init__(self): + super().__init__(AdminStatus) + + def __get__(self, instance, owner=None) -> ( + 'AdminStatusMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AdminStatus': + pass + + def __enter__(self) -> 'AdminStatus': + pass + + +class AdminStatus( + YANGContainer, + metaclass=AdminStatusMeta): + """ + YANG container handler. + + YANG name: admin-status + """ + + _yang_name: Final[str] = 'admin-status' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'last-change': ( + last_change := YANGLeafMember( + 'last-change', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'status': ( + status := YANGLeafMember( + 'status', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AdminStatus': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/status/oper_status/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/status/oper_status/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ab3508c5b8babc01483e2d3a2e2996481a28ef43 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/sdps/sdp/status/oper_status/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OperStatusMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: oper-status + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: oper-status + """ + + def __init__(self): + super().__init__(OperStatus) + + def __get__(self, instance, owner=None) -> ( + 'OperStatusMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'OperStatus': + pass + + def __enter__(self) -> 'OperStatus': + pass + + +class OperStatus( + YANGContainer, + metaclass=OperStatusMeta): + """ + YANG container handler. + + YANG name: oper-status + """ + + _yang_name: Final[str] = 'oper-status' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'status': ( + status := YANGLeafMember( + 'status', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'last-change': ( + last_change := YANGLeafMember( + 'last-change', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'OperStatus': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/service_tags/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/service_tags/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fceafd62985c5230276d129779bf35378d84e87d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/service_tags/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceTagsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-tags + """ + from .tag_opaque import TagOpaque + from .tag_type import TagType + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-tags + """ + + def __init__(self): + super().__init__(ServiceTags) + + def __get__(self, instance, owner=None) -> ( + 'ServiceTagsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceTags': + pass + + def __enter__(self) -> 'ServiceTags': + pass + + +class ServiceTags( + YANGContainer, + metaclass=ServiceTagsMeta): + """ + YANG container handler. + + YANG name: service-tags + """ + + _yang_name: Final[str] = 'service-tags' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tag-opaque': ( + tag_opaque := ( # YANGListMember( + ServiceTagsMeta. + TagOpaque. + yang_list_descriptor())), + + 'tag-type': ( + tag_type := ( # YANGListMember( + ServiceTagsMeta. + TagType. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceTags': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/service_tags/tag_opaque/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/service_tags/tag_opaque/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d40d27cb705b0fbf4970fa215054e46b4743d885 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/service_tags/tag_opaque/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TagOpaqueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tag-opaque + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tag-opaque + """ + + def __init__(self): + super().__init__(TagOpaque) + + def __get__(self, instance, owner=None) -> ( + 'TagOpaqueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['TagOpaque']: + pass + + def __iter__(self, key) -> Iterator['TagOpaque']: + return super().__iter__() + + def __getitem__(self, key) -> 'TagOpaque': + return super()[key] + + def __enter__(self) -> ( + 'TagOpaqueMeta.yang_list_descriptor'): + pass + + +class TagOpaque( + YANGListItem, + metaclass=TagOpaqueMeta): + """ + YANG list item handler. + + YANG name: tag-opaque + """ + + _yang_name: Final[str] = 'tag-opaque' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tag-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tag-name': ( + tag_name := YANGLeafMember( + 'tag-name', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TagOpaque': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/service_tags/tag_type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/service_tags/tag_type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b4fff2c3b44b9e1649b5eabb6b12cb36d376b6e1 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/service_tags/tag_type/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TagTypeMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tag-type + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tag-type + """ + + def __init__(self): + super().__init__(TagType) + + def __get__(self, instance, owner=None) -> ( + 'TagTypeMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['TagType']: + pass + + def __iter__(self, key) -> Iterator['TagType']: + return super().__iter__() + + def __getitem__(self, key) -> 'TagType': + return super()[key] + + def __enter__(self) -> ( + 'TagTypeMeta.yang_list_descriptor'): + pass + + +class TagType( + YANGListItem, + metaclass=TagTypeMeta): + """ + YANG list item handler. + + YANG name: tag-type + """ + + _yang_name: Final[str] = 'tag-type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tag-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tag-type': ( + tag_type := YANGLeafMember( + 'tag-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TagType': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b239a65e175236f7873bd8165ac2a2c423e1f448 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/__init__.py @@ -0,0 +1,101 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SloSlePolicyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: slo-sle-policy + """ + + from .standard import Standard + from .custom import Custom + + class standard_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: standard + """ + + def __init__(self): + super().__init__( + SloSlePolicyMeta.Standard) + + def __get__(self, instance, owner=None) -> ( + 'SloSlePolicyMeta.standard_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'SloSlePolicyMeta.Standard'): + pass + + def __enter__(self) -> ( + 'SloSlePolicyMeta.Standard'): + pass + + class custom_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: custom + """ + + def __init__(self): + super().__init__( + SloSlePolicyMeta.Custom) + + def __get__(self, instance, owner=None) -> ( + 'SloSlePolicyMeta.custom_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'SloSlePolicyMeta.Custom'): + pass + + def __enter__(self) -> ( + 'SloSlePolicyMeta.Custom'): + pass + + +class SloSlePolicy(YANGChoice, metaclass=SloSlePolicyMeta): + """ + YANG choice handler. + + YANG name: slo-sle-policy + """ + + _yang_name: Final[str] = 'slo-sle-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'standard': ( + standard := ( # YANGChoiceCase( + SloSlePolicyMeta. + standard_case_descriptor())), + + 'custom': ( + custom := ( # YANGChoiceCase( + SloSlePolicyMeta. + custom_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2d0c87599d2b498607615d75ec2bbaab7318af15 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class CustomMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: custom + """ + from .service_slo_sle_policy import ServiceSloSlePolicy + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: custom + """ + + def __init__(self): + super().__init__(Custom) + + def __get__(self, instance, owner=None) -> ( + 'CustomMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Custom': + pass + + def __enter__(self) -> 'Custom': + pass + + +class Custom( + YANGContainer, + metaclass=CustomMeta): + """ + YANG container handler. + + YANG name: custom + """ + + _yang_name: Final[str] = 'custom' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'service-slo-sle-policy': ( + service_slo_sle_policy := ( # YANGContainerMember( + CustomMeta. + ServiceSloSlePolicy. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Custom': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f20900d5bafe087db15381e30cca8d6c7555875c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/__init__.py @@ -0,0 +1,117 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceSloSlePolicyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-slo-sle-policy + """ + from .steering_constraints import SteeringConstraints + from .metric_bounds import MetricBounds + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-slo-sle-policy + """ + + def __init__(self): + super().__init__(ServiceSloSlePolicy) + + def __get__(self, instance, owner=None) -> ( + 'ServiceSloSlePolicyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceSloSlePolicy': + pass + + def __enter__(self) -> 'ServiceSloSlePolicy': + pass + + +class ServiceSloSlePolicy( + YANGContainer, + metaclass=ServiceSloSlePolicyMeta): + """ + YANG container handler. + + YANG name: service-slo-sle-policy + """ + + _yang_name: Final[str] = 'service-slo-sle-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'mtu': ( + mtu := YANGLeafMember( + 'mtu', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'max-occupancy-level': ( + max_occupancy_level := YANGLeafMember( + 'max-occupancy-level', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'isolation': ( + isolation := YANGLeafMember( + 'isolation', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'policy-description': ( + policy_description := YANGLeafMember( + 'policy-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'steering-constraints': ( + steering_constraints := ( # YANGContainerMember( + ServiceSloSlePolicyMeta. + SteeringConstraints. + yang_container_descriptor())), + + 'metric-bounds': ( + metric_bounds := ( # YANGContainerMember( + ServiceSloSlePolicyMeta. + MetricBounds. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceSloSlePolicy': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..85730b2d943861ca804a89d0a32ab69bcc27f5c0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricBoundsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: metric-bounds + """ + from .metric_bound import MetricBound + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: metric-bounds + """ + + def __init__(self): + super().__init__(MetricBounds) + + def __get__(self, instance, owner=None) -> ( + 'MetricBoundsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'MetricBounds': + pass + + def __enter__(self) -> 'MetricBounds': + pass + + +class MetricBounds( + YANGContainer, + metaclass=MetricBoundsMeta): + """ + YANG container handler. + + YANG name: metric-bounds + """ + + _yang_name: Final[str] = 'metric-bounds' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'metric-bound': ( + metric_bound := ( # YANGListMember( + MetricBoundsMeta. + MetricBound. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MetricBounds': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0cd58260dfa621982847da9dc6fd2bfd5c74331b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py @@ -0,0 +1,114 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricBoundMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: metric-bound + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: metric-bound + """ + + def __init__(self): + super().__init__(MetricBound) + + def __get__(self, instance, owner=None) -> ( + 'MetricBoundMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['MetricBound']: + pass + + def __iter__(self, key) -> Iterator['MetricBound']: + return super().__iter__() + + def __getitem__(self, key) -> 'MetricBound': + return super()[key] + + def __enter__(self) -> ( + 'MetricBoundMeta.yang_list_descriptor'): + pass + + +class MetricBound( + YANGListItem, + metaclass=MetricBoundMeta): + """ + YANG list item handler. + + YANG name: metric-bound + """ + + _yang_name: Final[str] = 'metric-bound' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'value-description': ( + value_description := YANGLeafMember( + 'value-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'bound': ( + bound := YANGLeafMember( + 'bound', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'metric-unit': ( + metric_unit := YANGLeafMember( + 'metric-unit', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MetricBound': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c308b850384ee650e0ea222b7776b52b378718fd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SteeringConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: steering-constraints + """ + from .path_constraints import PathConstraints + from .service_function import ServiceFunction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: steering-constraints + """ + + def __init__(self): + super().__init__(SteeringConstraints) + + def __get__(self, instance, owner=None) -> ( + 'SteeringConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'SteeringConstraints': + pass + + def __enter__(self) -> 'SteeringConstraints': + pass + + +class SteeringConstraints( + YANGContainer, + metaclass=SteeringConstraintsMeta): + """ + YANG container handler. + + YANG name: steering-constraints + """ + + _yang_name: Final[str] = 'steering-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-constraints': ( + path_constraints := ( # YANGContainerMember( + SteeringConstraintsMeta. + PathConstraints. + yang_container_descriptor())), + + 'service-function': ( + service_function := ( # YANGContainerMember( + SteeringConstraintsMeta. + ServiceFunction. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SteeringConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d34f1d097105a51fd50e9f351f61e915352319bd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-constraints + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-constraints + """ + + def __init__(self): + super().__init__(PathConstraints) + + def __get__(self, instance, owner=None) -> ( + 'PathConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathConstraints': + pass + + def __enter__(self) -> 'PathConstraints': + pass + + +class PathConstraints( + YANGContainer, + metaclass=PathConstraintsMeta): + """ + YANG container handler. + + YANG name: path-constraints + """ + + _yang_name: Final[str] = 'path-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2593c301f7b0b52ce5c155c0a8672714de5dae84 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/custom/service_slo_sle_policy/steering_constraints/service_function/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-function + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-function + """ + + def __init__(self): + super().__init__(ServiceFunction) + + def __get__(self, instance, owner=None) -> ( + 'ServiceFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceFunction': + pass + + def __enter__(self) -> 'ServiceFunction': + pass + + +class ServiceFunction( + YANGContainer, + metaclass=ServiceFunctionMeta): + """ + YANG container handler. + + YANG name: service-function + """ + + _yang_name: Final[str] = 'service-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/standard/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/standard/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..46e20b7346f1d22e7a61b81a4afb170d9ed36a5b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/slo_sle_policy/standard/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class StandardMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: standard + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: standard + """ + + def __init__(self): + super().__init__(Standard) + + def __get__(self, instance, owner=None) -> ( + 'StandardMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Standard': + pass + + def __enter__(self) -> 'Standard': + pass + + +class Standard( + YANGContainer, + metaclass=StandardMeta): + """ + YANG container handler. + + YANG name: standard + """ + + _yang_name: Final[str] = 'standard' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'slo-sle-template': ( + slo_sle_template := YANGLeafMember( + 'slo-sle-template', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Standard': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/status/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/status/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b4239eb7df15eb9629be735267d4fb31ae46af03 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/status/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class StatusMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: status + """ + from .admin_status import AdminStatus + from .oper_status import OperStatus + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: status + """ + + def __init__(self): + super().__init__(Status) + + def __get__(self, instance, owner=None) -> ( + 'StatusMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Status': + pass + + def __enter__(self) -> 'Status': + pass + + +class Status( + YANGContainer, + metaclass=StatusMeta): + """ + YANG container handler. + + YANG name: status + """ + + _yang_name: Final[str] = 'status' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'admin-status': ( + admin_status := ( # YANGContainerMember( + StatusMeta. + AdminStatus. + yang_container_descriptor())), + + 'oper-status': ( + oper_status := ( # YANGContainerMember( + StatusMeta. + OperStatus. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Status': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/status/admin_status/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/status/admin_status/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f5581ef12dac29ce3050652c8c969a76f0ac88fb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/status/admin_status/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AdminStatusMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: admin-status + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: admin-status + """ + + def __init__(self): + super().__init__(AdminStatus) + + def __get__(self, instance, owner=None) -> ( + 'AdminStatusMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AdminStatus': + pass + + def __enter__(self) -> 'AdminStatus': + pass + + +class AdminStatus( + YANGContainer, + metaclass=AdminStatusMeta): + """ + YANG container handler. + + YANG name: admin-status + """ + + _yang_name: Final[str] = 'admin-status' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'last-change': ( + last_change := YANGLeafMember( + 'last-change', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'status': ( + status := YANGLeafMember( + 'status', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AdminStatus': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/status/oper_status/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/status/oper_status/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69e53ef62d967bc5dbd072cf4f405d60c28be30 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/status/oper_status/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OperStatusMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: oper-status + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: oper-status + """ + + def __init__(self): + super().__init__(OperStatus) + + def __get__(self, instance, owner=None) -> ( + 'OperStatusMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'OperStatus': + pass + + def __enter__(self) -> 'OperStatus': + pass + + +class OperStatus( + YANGContainer, + metaclass=OperStatusMeta): + """ + YANG container handler. + + YANG name: oper-status + """ + + _yang_name: Final[str] = 'oper-status' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'last-change': ( + last_change := YANGLeafMember( + 'last-change', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'status': ( + status := YANGLeafMember( + 'status', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'OperStatus': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/te_topology_identifier/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/te_topology_identifier/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b76cce7a32018d0f77c2a9ac3c7fbbc94665680f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slice_service/te_topology_identifier/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeTopologyIdentifierMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-topology-identifier + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-topology-identifier + """ + + def __init__(self): + super().__init__(TeTopologyIdentifier) + + def __get__(self, instance, owner=None) -> ( + 'TeTopologyIdentifierMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeTopologyIdentifier': + pass + + def __enter__(self) -> 'TeTopologyIdentifier': + pass + + +class TeTopologyIdentifier( + YANGContainer, + metaclass=TeTopologyIdentifierMeta): + """ + YANG container handler. + + YANG name: te-topology-identifier + """ + + _yang_name: Final[str] = 'te-topology-identifier' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'client-id': ( + client_id := YANGLeafMember( + 'client-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'topology-id': ( + topology_id := YANGLeafMember( + 'topology-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'provider-id': ( + provider_id := YANGLeafMember( + 'provider-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeTopologyIdentifier': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..27cda68070b24236354d46b094d0ad3787ab4485 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SloSleTemplatesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: slo-sle-templates + """ + from .slo_sle_template import SloSleTemplate + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: slo-sle-templates + """ + + def __init__(self): + super().__init__(SloSleTemplates) + + def __get__(self, instance, owner=None) -> ( + 'SloSleTemplatesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'SloSleTemplates': + pass + + def __enter__(self) -> 'SloSleTemplates': + pass + + +class SloSleTemplates( + YANGContainer, + metaclass=SloSleTemplatesMeta): + """ + YANG container handler. + + YANG name: slo-sle-templates + """ + + _yang_name: Final[str] = 'slo-sle-templates' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'slo-sle-template': ( + slo_sle_template := ( # YANGListMember( + SloSleTemplatesMeta. + SloSleTemplate. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SloSleTemplates': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e97edc736f2f5435711ad71a78313fa2f98b446b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/__init__.py @@ -0,0 +1,115 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SloSleTemplateMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: slo-sle-template + """ + from .service_slo_sle_policy import ServiceSloSlePolicy + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: slo-sle-template + """ + + def __init__(self): + super().__init__(SloSleTemplate) + + def __get__(self, instance, owner=None) -> ( + 'SloSleTemplateMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['SloSleTemplate']: + pass + + def __iter__(self, key) -> Iterator['SloSleTemplate']: + return super().__iter__() + + def __getitem__(self, key) -> 'SloSleTemplate': + return super()[key] + + def __enter__(self) -> ( + 'SloSleTemplateMeta.yang_list_descriptor'): + pass + + +class SloSleTemplate( + YANGListItem, + metaclass=SloSleTemplateMeta): + """ + YANG list item handler. + + YANG name: slo-sle-template + """ + + _yang_name: Final[str] = 'slo-sle-template' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'id': ( + id := YANGLeafMember( + 'id', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'template-ref': ( + template_ref := YANGLeafMember( + 'template-ref', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'template-description': ( + template_description := YANGLeafMember( + 'template-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'service-slo-sle-policy': ( + service_slo_sle_policy := ( # YANGContainerMember( + SloSleTemplateMeta. + ServiceSloSlePolicy. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SloSleTemplate': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6992f5bf7f3fc87ff009bcf075de2cf2cd698f12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/__init__.py @@ -0,0 +1,117 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceSloSlePolicyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-slo-sle-policy + """ + from .metric_bounds import MetricBounds + from .steering_constraints import SteeringConstraints + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-slo-sle-policy + """ + + def __init__(self): + super().__init__(ServiceSloSlePolicy) + + def __get__(self, instance, owner=None) -> ( + 'ServiceSloSlePolicyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceSloSlePolicy': + pass + + def __enter__(self) -> 'ServiceSloSlePolicy': + pass + + +class ServiceSloSlePolicy( + YANGContainer, + metaclass=ServiceSloSlePolicyMeta): + """ + YANG container handler. + + YANG name: service-slo-sle-policy + """ + + _yang_name: Final[str] = 'service-slo-sle-policy' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'mtu': ( + mtu := YANGLeafMember( + 'mtu', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'max-occupancy-level': ( + max_occupancy_level := YANGLeafMember( + 'max-occupancy-level', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'isolation': ( + isolation := YANGLeafMember( + 'isolation', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'policy-description': ( + policy_description := YANGLeafMember( + 'policy-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'metric-bounds': ( + metric_bounds := ( # YANGContainerMember( + ServiceSloSlePolicyMeta. + MetricBounds. + yang_container_descriptor())), + + 'steering-constraints': ( + steering_constraints := ( # YANGContainerMember( + ServiceSloSlePolicyMeta. + SteeringConstraints. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceSloSlePolicy': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/metric_bounds/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/metric_bounds/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..85730b2d943861ca804a89d0a32ab69bcc27f5c0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/metric_bounds/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricBoundsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: metric-bounds + """ + from .metric_bound import MetricBound + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: metric-bounds + """ + + def __init__(self): + super().__init__(MetricBounds) + + def __get__(self, instance, owner=None) -> ( + 'MetricBoundsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'MetricBounds': + pass + + def __enter__(self) -> 'MetricBounds': + pass + + +class MetricBounds( + YANGContainer, + metaclass=MetricBoundsMeta): + """ + YANG container handler. + + YANG name: metric-bounds + """ + + _yang_name: Final[str] = 'metric-bounds' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'metric-bound': ( + metric_bound := ( # YANGListMember( + MetricBoundsMeta. + MetricBound. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MetricBounds': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2664a9278a5332d04479df4c5026f38ec2f379d9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/metric_bounds/metric_bound/__init__.py @@ -0,0 +1,114 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricBoundMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: metric-bound + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: metric-bound + """ + + def __init__(self): + super().__init__(MetricBound) + + def __get__(self, instance, owner=None) -> ( + 'MetricBoundMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['MetricBound']: + pass + + def __iter__(self, key) -> Iterator['MetricBound']: + return super().__iter__() + + def __getitem__(self, key) -> 'MetricBound': + return super()[key] + + def __enter__(self) -> ( + 'MetricBoundMeta.yang_list_descriptor'): + pass + + +class MetricBound( + YANGListItem, + metaclass=MetricBoundMeta): + """ + YANG list item handler. + + YANG name: metric-bound + """ + + _yang_name: Final[str] = 'metric-bound' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'metric-unit': ( + metric_unit := YANGLeafMember( + 'metric-unit', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'value-description': ( + value_description := YANGLeafMember( + 'value-description', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + + 'bound': ( + bound := YANGLeafMember( + 'bound', + 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service', + 'ietf-network-slice-service')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MetricBound': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/steering_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/steering_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e2c022caf902743b8abe798b61b8f1439d276862 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/steering_constraints/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SteeringConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: steering-constraints + """ + from .service_function import ServiceFunction + from .path_constraints import PathConstraints + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: steering-constraints + """ + + def __init__(self): + super().__init__(SteeringConstraints) + + def __get__(self, instance, owner=None) -> ( + 'SteeringConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'SteeringConstraints': + pass + + def __enter__(self) -> 'SteeringConstraints': + pass + + +class SteeringConstraints( + YANGContainer, + metaclass=SteeringConstraintsMeta): + """ + YANG container handler. + + YANG name: steering-constraints + """ + + _yang_name: Final[str] = 'steering-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'service-function': ( + service_function := ( # YANGContainerMember( + SteeringConstraintsMeta. + ServiceFunction. + yang_container_descriptor())), + + 'path-constraints': ( + path_constraints := ( # YANGContainerMember( + SteeringConstraintsMeta. + PathConstraints. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SteeringConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d34f1d097105a51fd50e9f351f61e915352319bd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/steering_constraints/path_constraints/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-constraints + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-constraints + """ + + def __init__(self): + super().__init__(PathConstraints) + + def __get__(self, instance, owner=None) -> ( + 'PathConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathConstraints': + pass + + def __enter__(self) -> 'PathConstraints': + pass + + +class PathConstraints( + YANGContainer, + metaclass=PathConstraintsMeta): + """ + YANG container handler. + + YANG name: path-constraints + """ + + _yang_name: Final[str] = 'path-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/steering_constraints/service_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/steering_constraints/service_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2593c301f7b0b52ce5c155c0a8672714de5dae84 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/network_slice_services/slo_sle_templates/slo_sle_template/service_slo_sle_policy/steering_constraints/service_function/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ServiceFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: service-function + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: service-function + """ + + def __init__(self): + super().__init__(ServiceFunction) + + def __get__(self, instance, owner=None) -> ( + 'ServiceFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ServiceFunction': + pass + + def __enter__(self) -> 'ServiceFunction': + pass + + +class ServiceFunction( + YANGContainer, + metaclass=ServiceFunctionMeta): + """ + YANG container handler. + + YANG name: service-function + """ + + _yang_name: Final[str] = 'service-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-slice-service' + _yang_module_name: Final[str] = 'ietf-network-slice-service' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ServiceFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..55faa977ba04330042964cb79ab2a3bdd8a6571c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NetworksMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: networks + """ + from .te import Te + from .network import Network + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: networks + """ + + def __init__(self): + super().__init__(Networks) + + def __get__(self, instance, owner=None) -> ( + 'NetworksMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Networks': + pass + + def __enter__(self) -> 'Networks': + pass + + +class Networks( + YANGContainer, + metaclass=NetworksMeta): + """ + YANG container handler. + + YANG name: networks + """ + + _yang_name: Final[str] = 'networks' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network' + _yang_module_name: Final[str] = 'ietf-network' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te': ( + te := ( # YANGContainerMember( + NetworksMeta. + Te. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'network': ( + network := ( # YANGListMember( + NetworksMeta. + Network. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Networks': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..44952bf764009ce37b74d8ab45cf20dc0e0e450e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/__init__.py @@ -0,0 +1,138 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NetworkMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: network + """ + from .te import Te + from .te_topology_identifier import TeTopologyIdentifier + from .network_types import NetworkTypes + from .node import Node + from .supporting_network import SupportingNetwork + from .link import Link + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: network + """ + + def __init__(self): + super().__init__(Network) + + def __get__(self, instance, owner=None) -> ( + 'NetworkMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Network']: + pass + + def __iter__(self, key) -> Iterator['Network']: + return super().__iter__() + + def __getitem__(self, key) -> 'Network': + return super()[key] + + def __enter__(self) -> ( + 'NetworkMeta.yang_list_descriptor'): + pass + + +class Network( + YANGListItem, + metaclass=NetworkMeta): + """ + YANG list item handler. + + YANG name: network + """ + + _yang_name: Final[str] = 'network' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network' + _yang_module_name: Final[str] = 'ietf-network' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'network-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-id': ( + network_id := YANGLeafMember( + 'network-id', + 'urn:ietf:params:xml:ns:yang:ietf-network', + 'ietf-network')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te': ( + te := ( # YANGContainerMember( + NetworkMeta. + Te. + yang_container_descriptor())), + + 'te-topology-identifier': ( + te_topology_identifier := ( # YANGContainerMember( + NetworkMeta. + TeTopologyIdentifier. + yang_container_descriptor())), + + 'network-types': ( + network_types := ( # YANGContainerMember( + NetworkMeta. + NetworkTypes. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'node': ( + node := ( # YANGListMember( + NetworkMeta. + Node. + yang_list_descriptor())), + + 'supporting-network': ( + supporting_network := ( # YANGListMember( + NetworkMeta. + SupportingNetwork. + yang_list_descriptor())), + + 'link': ( + link := ( # YANGListMember( + NetworkMeta. + Link. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Network': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3efc3e1518f16330422d43ba925ea7713a2cef25 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/__init__.py @@ -0,0 +1,124 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LinkMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: link + """ + from .source import Source + from .destination import Destination + from .te import Te + from .supporting_link import SupportingLink + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: link + """ + + def __init__(self): + super().__init__(Link) + + def __get__(self, instance, owner=None) -> ( + 'LinkMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Link']: + pass + + def __iter__(self, key) -> Iterator['Link']: + return super().__iter__() + + def __getitem__(self, key) -> 'Link': + return super()[key] + + def __enter__(self) -> ( + 'LinkMeta.yang_list_descriptor'): + pass + + +class Link( + YANGListItem, + metaclass=LinkMeta): + """ + YANG list item handler. + + YANG name: link + """ + + _yang_name: Final[str] = 'link' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-topology' + _yang_module_name: Final[str] = 'ietf-network-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'link-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-id': ( + link_id := YANGLeafMember( + 'link-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-topology', + 'ietf-network-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'source': ( + source := ( # YANGContainerMember( + LinkMeta. + Source. + yang_container_descriptor())), + + 'destination': ( + destination := ( # YANGContainerMember( + LinkMeta. + Destination. + yang_container_descriptor())), + + 'te': ( + te := ( # YANGContainerMember( + LinkMeta. + Te. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'supporting-link': ( + supporting_link := ( # YANGListMember( + LinkMeta. + SupportingLink. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Link': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/destination/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/destination/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..387af3071c585daebb4f11cb2bc7890a37967e56 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/destination/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class DestinationMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: destination + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: destination + """ + + def __init__(self): + super().__init__(Destination) + + def __get__(self, instance, owner=None) -> ( + 'DestinationMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Destination': + pass + + def __enter__(self) -> 'Destination': + pass + + +class Destination( + YANGContainer, + metaclass=DestinationMeta): + """ + YANG container handler. + + YANG name: destination + """ + + _yang_name: Final[str] = 'destination' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-topology' + _yang_module_name: Final[str] = 'ietf-network-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'dest-node': ( + dest_node := YANGLeafMember( + 'dest-node', + 'urn:ietf:params:xml:ns:yang:ietf-network-topology', + 'ietf-network-topology')), + + 'dest-tp': ( + dest_tp := YANGLeafMember( + 'dest-tp', + 'urn:ietf:params:xml:ns:yang:ietf-network-topology', + 'ietf-network-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Destination': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/source/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/source/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f1ea95f113d40f596ea39edaa5d1b07273f22148 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/source/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SourceMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: source + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: source + """ + + def __init__(self): + super().__init__(Source) + + def __get__(self, instance, owner=None) -> ( + 'SourceMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Source': + pass + + def __enter__(self) -> 'Source': + pass + + +class Source( + YANGContainer, + metaclass=SourceMeta): + """ + YANG container handler. + + YANG name: source + """ + + _yang_name: Final[str] = 'source' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-topology' + _yang_module_name: Final[str] = 'ietf-network-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'source-tp': ( + source_tp := YANGLeafMember( + 'source-tp', + 'urn:ietf:params:xml:ns:yang:ietf-network-topology', + 'ietf-network-topology')), + + 'source-node': ( + source_node := YANGLeafMember( + 'source-node', + 'urn:ietf:params:xml:ns:yang:ietf-network-topology', + 'ietf-network-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Source': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/supporting_link/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/supporting_link/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dc99caa282f1b3c61577107a169430654949fe3f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/supporting_link/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SupportingLinkMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: supporting-link + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: supporting-link + """ + + def __init__(self): + super().__init__(SupportingLink) + + def __get__(self, instance, owner=None) -> ( + 'SupportingLinkMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['SupportingLink']: + pass + + def __iter__(self, key) -> Iterator['SupportingLink']: + return super().__iter__() + + def __getitem__(self, key) -> 'SupportingLink': + return super()[key] + + def __enter__(self) -> ( + 'SupportingLinkMeta.yang_list_descriptor'): + pass + + +class SupportingLink( + YANGListItem, + metaclass=SupportingLinkMeta): + """ + YANG list item handler. + + YANG name: supporting-link + """ + + _yang_name: Final[str] = 'supporting-link' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-topology' + _yang_module_name: Final[str] = 'ietf-network-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'network-ref', + 'link-ref', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-ref': ( + link_ref := YANGLeafMember( + 'link-ref', + 'urn:ietf:params:xml:ns:yang:ietf-network-topology', + 'ietf-network-topology')), + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-network-topology', + 'ietf-network-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SupportingLink': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2fac1a941b3f2b45da7b78f3f4eef6cace58f3b5 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/__init__.py @@ -0,0 +1,155 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te + """ + from .statistics import Statistics + from .te_link_attributes import TeLinkAttributes + from .underlay import Underlay + from .recovery import Recovery + from .information_source_state import InformationSourceState + from .information_source_entry import InformationSourceEntry + from .bundle_stack_level import BundleStackLevel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te + """ + + def __init__(self): + super().__init__(Te) + + def __get__(self, instance, owner=None) -> ( + 'TeMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Te': + pass + + def __enter__(self) -> 'Te': + pass + + +class Te( + YANGContainer, + metaclass=TeMeta): + """ + YANG container handler. + + YANG name: te + """ + + _yang_name: Final[str] = 'te' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'is-transitional': ( + is_transitional := YANGLeafMember( + 'is-transitional', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'information-source-instance': ( + information_source_instance := YANGLeafMember( + 'information-source-instance', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'oper-status': ( + oper_status := YANGLeafMember( + 'oper-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'information-source': ( + information_source := YANGLeafMember( + 'information-source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'statistics': ( + statistics := ( # YANGContainerMember( + TeMeta. + Statistics. + yang_container_descriptor())), + + 'te-link-attributes': ( + te_link_attributes := ( # YANGContainerMember( + TeMeta. + TeLinkAttributes. + yang_container_descriptor())), + + 'underlay': ( + underlay := ( # YANGContainerMember( + TeMeta. + Underlay. + yang_container_descriptor())), + + 'recovery': ( + recovery := ( # YANGContainerMember( + TeMeta. + Recovery. + yang_container_descriptor())), + + 'information-source-state': ( + information_source_state := ( # YANGContainerMember( + TeMeta. + InformationSourceState. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'information-source-entry': ( + information_source_entry := ( # YANGListMember( + TeMeta. + InformationSourceEntry. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Te': + instance = super().__new__(cls) + instance._yang_choices = { + + 'bundle-stack-level': + TeMeta.BundleStackLevel( + instance), + } + return instance + + @property + def bundle_stack_level(self) -> ( + TeMeta.BundleStackLevel): + return self._yang_choices['bundle-stack-level'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..225c39aa448d3165a61a66735cb5755c9eaa4908 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/__init__.py @@ -0,0 +1,101 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BundleStackLevelMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: bundle-stack-level + """ + + from .component import Component + from .bundle import Bundle + + class component_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: component + """ + + def __init__(self): + super().__init__( + BundleStackLevelMeta.Component) + + def __get__(self, instance, owner=None) -> ( + 'BundleStackLevelMeta.component_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'BundleStackLevelMeta.Component'): + pass + + def __enter__(self) -> ( + 'BundleStackLevelMeta.Component'): + pass + + class bundle_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: bundle + """ + + def __init__(self): + super().__init__( + BundleStackLevelMeta.Bundle) + + def __get__(self, instance, owner=None) -> ( + 'BundleStackLevelMeta.bundle_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'BundleStackLevelMeta.Bundle'): + pass + + def __enter__(self) -> ( + 'BundleStackLevelMeta.Bundle'): + pass + + +class BundleStackLevel(YANGChoice, metaclass=BundleStackLevelMeta): + """ + YANG choice handler. + + YANG name: bundle-stack-level + """ + + _yang_name: Final[str] = 'bundle-stack-level' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'component': ( + component := ( # YANGChoiceCase( + BundleStackLevelMeta. + component_case_descriptor())), + + 'bundle': ( + bundle := ( # YANGChoiceCase( + BundleStackLevelMeta. + bundle_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/bundle/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/bundle/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2ac76501adeb07f82ad08b8084a64534cca4a163 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/bundle/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BundleMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: bundle + """ + from .bundled_links import BundledLinks + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: bundle + """ + + def __init__(self): + super().__init__(Bundle) + + def __get__(self, instance, owner=None) -> ( + 'BundleMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Bundle': + pass + + def __enter__(self) -> 'Bundle': + pass + + +class Bundle( + YANGContainer, + metaclass=BundleMeta): + """ + YANG container handler. + + YANG name: bundle + """ + + _yang_name: Final[str] = 'bundle' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'bundled-links': ( + bundled_links := ( # YANGContainerMember( + BundleMeta. + BundledLinks. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Bundle': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/bundle/bundled_links/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/bundle/bundled_links/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fc2b9edfb5c0d0a12233c23e4b0982fc72020ae0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/bundle/bundled_links/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BundledLinksMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: bundled-links + """ + from .bundled_link import BundledLink + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: bundled-links + """ + + def __init__(self): + super().__init__(BundledLinks) + + def __get__(self, instance, owner=None) -> ( + 'BundledLinksMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'BundledLinks': + pass + + def __enter__(self) -> 'BundledLinks': + pass + + +class BundledLinks( + YANGContainer, + metaclass=BundledLinksMeta): + """ + YANG container handler. + + YANG name: bundled-links + """ + + _yang_name: Final[str] = 'bundled-links' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'bundled-link': ( + bundled_link := ( # YANGListMember( + BundledLinksMeta. + BundledLink. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'BundledLinks': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/bundle/bundled_links/bundled_link/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/bundle/bundled_links/bundled_link/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b10b2d452b813e8821571384ff36553830cea9b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/bundle/bundled_links/bundled_link/__init__.py @@ -0,0 +1,108 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BundledLinkMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: bundled-link + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: bundled-link + """ + + def __init__(self): + super().__init__(BundledLink) + + def __get__(self, instance, owner=None) -> ( + 'BundledLinkMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['BundledLink']: + pass + + def __iter__(self, key) -> Iterator['BundledLink']: + return super().__iter__() + + def __getitem__(self, key) -> 'BundledLink': + return super()[key] + + def __enter__(self) -> ( + 'BundledLinkMeta.yang_list_descriptor'): + pass + + +class BundledLink( + YANGListItem, + metaclass=BundledLinkMeta): + """ + YANG list item handler. + + YANG name: bundled-link + """ + + _yang_name: Final[str] = 'bundled-link' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'sequence', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sequence': ( + sequence := YANGLeafMember( + 'sequence', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'src-tp-ref': ( + src_tp_ref := YANGLeafMember( + 'src-tp-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'des-tp-ref': ( + des_tp_ref := YANGLeafMember( + 'des-tp-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'BundledLink': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/component/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/component/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8cd4a23746aa284e47784cb4fccdf7278ebce34 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/component/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ComponentMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: component + """ + from .component_links import ComponentLinks + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: component + """ + + def __init__(self): + super().__init__(Component) + + def __get__(self, instance, owner=None) -> ( + 'ComponentMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Component': + pass + + def __enter__(self) -> 'Component': + pass + + +class Component( + YANGContainer, + metaclass=ComponentMeta): + """ + YANG container handler. + + YANG name: component + """ + + _yang_name: Final[str] = 'component' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'component-links': ( + component_links := ( # YANGContainerMember( + ComponentMeta. + ComponentLinks. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Component': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/component/component_links/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/component/component_links/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2dea8fc98c2766683324fb1271d8adb121b4dea8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/component/component_links/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ComponentLinksMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: component-links + """ + from .component_link import ComponentLink + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: component-links + """ + + def __init__(self): + super().__init__(ComponentLinks) + + def __get__(self, instance, owner=None) -> ( + 'ComponentLinksMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ComponentLinks': + pass + + def __enter__(self) -> 'ComponentLinks': + pass + + +class ComponentLinks( + YANGContainer, + metaclass=ComponentLinksMeta): + """ + YANG container handler. + + YANG name: component-links + """ + + _yang_name: Final[str] = 'component-links' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'component-link': ( + component_link := ( # YANGListMember( + ComponentLinksMeta. + ComponentLink. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ComponentLinks': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/component/component_links/component_link/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/component/component_links/component_link/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6195320b1b05440e98cb09c672a9286f7ac08017 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/bundle_stack_level/component/component_links/component_link/__init__.py @@ -0,0 +1,108 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ComponentLinkMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: component-link + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: component-link + """ + + def __init__(self): + super().__init__(ComponentLink) + + def __get__(self, instance, owner=None) -> ( + 'ComponentLinkMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['ComponentLink']: + pass + + def __iter__(self, key) -> Iterator['ComponentLink']: + return super().__iter__() + + def __getitem__(self, key) -> 'ComponentLink': + return super()[key] + + def __enter__(self) -> ( + 'ComponentLinkMeta.yang_list_descriptor'): + pass + + +class ComponentLink( + YANGListItem, + metaclass=ComponentLinkMeta): + """ + YANG list item handler. + + YANG name: component-link + """ + + _yang_name: Final[str] = 'component-link' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'sequence', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'src-interface-ref': ( + src_interface_ref := YANGLeafMember( + 'src-interface-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'sequence': ( + sequence := YANGLeafMember( + 'sequence', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'des-interface-ref': ( + des_interface_ref := YANGLeafMember( + 'des-interface-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ComponentLink': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aacb98f85b2ac241f3599daa93b27fc0f520c8ff --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/__init__.py @@ -0,0 +1,195 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class InformationSourceEntryMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: information-source-entry + """ + from .max_link_bandwidth import MaxLinkBandwidth + from .label_restrictions import LabelRestrictions + from .information_source_state import InformationSourceState + from .max_resv_link_bandwidth import MaxResvLinkBandwidth + from .te_srlgs import TeSrlgs + from .te_nsrlgs import TeNsrlgs + from .interface_switching_capability import InterfaceSwitchingCapability + from .unreserved_bandwidth import UnreservedBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: information-source-entry + """ + + def __init__(self): + super().__init__(InformationSourceEntry) + + def __get__(self, instance, owner=None) -> ( + 'InformationSourceEntryMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['InformationSourceEntry']: + pass + + def __iter__(self, key) -> Iterator['InformationSourceEntry']: + return super().__iter__() + + def __getitem__(self, key) -> 'InformationSourceEntry': + return super()[key] + + def __enter__(self) -> ( + 'InformationSourceEntryMeta.yang_list_descriptor'): + pass + + +class InformationSourceEntry( + YANGListItem, + metaclass=InformationSourceEntryMeta): + """ + YANG list item handler. + + YANG name: information-source-entry + """ + + _yang_name: Final[str] = 'information-source-entry' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'information-source', + 'information-source-instance', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'information-source-instance': ( + information_source_instance := YANGLeafMember( + 'information-source-instance', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'te-igp-metric': ( + te_igp_metric := YANGLeafMember( + 'te-igp-metric', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'te-default-metric': ( + te_default_metric := YANGLeafMember( + 'te-default-metric', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'te-delay-metric': ( + te_delay_metric := YANGLeafMember( + 'te-delay-metric', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-index': ( + link_index := YANGLeafMember( + 'link-index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-protection-type': ( + link_protection_type := YANGLeafMember( + 'link-protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'administrative-group': ( + administrative_group := YANGLeafMember( + 'administrative-group', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'information-source': ( + information_source := YANGLeafMember( + 'information-source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'max-link-bandwidth': ( + max_link_bandwidth := ( # YANGContainerMember( + InformationSourceEntryMeta. + MaxLinkBandwidth. + yang_container_descriptor())), + + 'label-restrictions': ( + label_restrictions := ( # YANGContainerMember( + InformationSourceEntryMeta. + LabelRestrictions. + yang_container_descriptor())), + + 'information-source-state': ( + information_source_state := ( # YANGContainerMember( + InformationSourceEntryMeta. + InformationSourceState. + yang_container_descriptor())), + + 'max-resv-link-bandwidth': ( + max_resv_link_bandwidth := ( # YANGContainerMember( + InformationSourceEntryMeta. + MaxResvLinkBandwidth. + yang_container_descriptor())), + + 'te-srlgs': ( + te_srlgs := ( # YANGContainerMember( + InformationSourceEntryMeta. + TeSrlgs. + yang_container_descriptor())), + + 'te-nsrlgs': ( + te_nsrlgs := ( # YANGContainerMember( + InformationSourceEntryMeta. + TeNsrlgs. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'interface-switching-capability': ( + interface_switching_capability := ( # YANGListMember( + InformationSourceEntryMeta. + InterfaceSwitchingCapability. + yang_list_descriptor())), + + 'unreserved-bandwidth': ( + unreserved_bandwidth := ( # YANGListMember( + InformationSourceEntryMeta. + UnreservedBandwidth. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'InformationSourceEntry': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/information_source_state/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/information_source_state/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..26d315f6a43287274e5b410c83c64a950c07014d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/information_source_state/__init__.py @@ -0,0 +1,104 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class InformationSourceStateMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: information-source-state + """ + from .topology import Topology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: information-source-state + """ + + def __init__(self): + super().__init__(InformationSourceState) + + def __get__(self, instance, owner=None) -> ( + 'InformationSourceStateMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'InformationSourceState': + pass + + def __enter__(self) -> 'InformationSourceState': + pass + + +class InformationSourceState( + YANGContainer, + metaclass=InformationSourceStateMeta): + """ + YANG container handler. + + YANG name: information-source-state + """ + + _yang_name: Final[str] = 'information-source-state' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-instance': ( + network_instance := YANGLeafMember( + 'network-instance', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'credibility-preference': ( + credibility_preference := YANGLeafMember( + 'credibility-preference', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'logical-network-element': ( + logical_network_element := YANGLeafMember( + 'logical-network-element', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'topology': ( + topology := ( # YANGContainerMember( + InformationSourceStateMeta. + Topology. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'InformationSourceState': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/information_source_state/topology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/information_source_state/topology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..63598ce3305f3b8b540d2d10d31cf66604ea175c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/information_source_state/topology/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TopologyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: topology + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: topology + """ + + def __init__(self): + super().__init__(Topology) + + def __get__(self, instance, owner=None) -> ( + 'TopologyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Topology': + pass + + def __enter__(self) -> 'Topology': + pass + + +class Topology( + YANGContainer, + metaclass=TopologyMeta): + """ + YANG container handler. + + YANG name: topology + """ + + _yang_name: Final[str] = 'topology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-ref': ( + link_ref := YANGLeafMember( + 'link-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Topology': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..42361e143910d3dc4963a100c961f548c4740f4a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/__init__.py @@ -0,0 +1,110 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class InterfaceSwitchingCapabilityMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: interface-switching-capability + """ + from .max_lsp_bandwidth import MaxLspBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: interface-switching-capability + """ + + def __init__(self): + super().__init__(InterfaceSwitchingCapability) + + def __get__(self, instance, owner=None) -> ( + 'InterfaceSwitchingCapabilityMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['InterfaceSwitchingCapability']: + pass + + def __iter__(self, key) -> Iterator['InterfaceSwitchingCapability']: + return super().__iter__() + + def __getitem__(self, key) -> 'InterfaceSwitchingCapability': + return super()[key] + + def __enter__(self) -> ( + 'InterfaceSwitchingCapabilityMeta.yang_list_descriptor'): + pass + + +class InterfaceSwitchingCapability( + YANGListItem, + metaclass=InterfaceSwitchingCapabilityMeta): + """ + YANG list item handler. + + YANG name: interface-switching-capability + """ + + _yang_name: Final[str] = 'interface-switching-capability' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'switching-capability', + 'encoding', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'switching-capability': ( + switching_capability := YANGLeafMember( + 'switching-capability', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'encoding': ( + encoding := YANGLeafMember( + 'encoding', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'max-lsp-bandwidth': ( + max_lsp_bandwidth := ( # YANGListMember( + InterfaceSwitchingCapabilityMeta. + MaxLspBandwidth. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'InterfaceSwitchingCapability': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ddad298bbc0cc7c626bd869965fe6da4630b6fb5 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MaxLspBandwidthMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: max-lsp-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: max-lsp-bandwidth + """ + + def __init__(self): + super().__init__(MaxLspBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'MaxLspBandwidthMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['MaxLspBandwidth']: + pass + + def __iter__(self, key) -> Iterator['MaxLspBandwidth']: + return super().__iter__() + + def __getitem__(self, key) -> 'MaxLspBandwidth': + return super()[key] + + def __enter__(self) -> ( + 'MaxLspBandwidthMeta.yang_list_descriptor'): + pass + + +class MaxLspBandwidth( + YANGListItem, + metaclass=MaxLspBandwidthMeta): + """ + YANG list item handler. + + YANG name: max-lsp-bandwidth + """ + + _yang_name: Final[str] = 'max-lsp-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'priority', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'priority': ( + priority := YANGLeafMember( + 'priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + MaxLspBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MaxLspBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29f30ca794c567238bb34de6d5de219f72b68cca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-restrictions + """ + from .label_restriction import LabelRestriction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-restrictions + """ + + def __init__(self): + super().__init__(LabelRestrictions) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelRestrictions': + pass + + def __enter__(self) -> 'LabelRestrictions': + pass + + +class LabelRestrictions( + YANGContainer, + metaclass=LabelRestrictionsMeta): + """ + YANG container handler. + + YANG name: label-restrictions + """ + + _yang_name: Final[str] = 'label-restrictions' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'label-restriction': ( + label_restriction := ( # YANGListMember( + LabelRestrictionsMeta. + LabelRestriction. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestrictions': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1f85292e3a5a398b30f523c488c31588fc79925c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: label-restriction + """ + from .label_step import LabelStep + from .label_end import LabelEnd + from .label_start import LabelStart + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: label-restriction + """ + + def __init__(self): + super().__init__(LabelRestriction) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LabelRestriction']: + pass + + def __iter__(self, key) -> Iterator['LabelRestriction']: + return super().__iter__() + + def __getitem__(self, key) -> 'LabelRestriction': + return super()[key] + + def __enter__(self) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + pass + + +class LabelRestriction( + YANGListItem, + metaclass=LabelRestrictionMeta): + """ + YANG list item handler. + + YANG name: label-restriction + """ + + _yang_name: Final[str] = 'label-restriction' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'range-bitmap': ( + range_bitmap := YANGLeafMember( + 'range-bitmap', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restriction': ( + restriction := YANGLeafMember( + 'restriction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-step': ( + label_step := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStep. + yang_container_descriptor())), + + 'label-end': ( + label_end := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelEnd. + yang_container_descriptor())), + + 'label-start': ( + label_start := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStart. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestriction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ad525773e032b7b224f5b661e728ffe8950e98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelEndMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-end + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-end + """ + + def __init__(self): + super().__init__(LabelEnd) + + def __get__(self, instance, owner=None) -> ( + 'LabelEndMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelEnd': + pass + + def __enter__(self) -> 'LabelEnd': + pass + + +class LabelEnd( + YANGContainer, + metaclass=LabelEndMeta): + """ + YANG container handler. + + YANG name: label-end + """ + + _yang_name: Final[str] = 'label-end' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelEndMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelEnd': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8985523ba0c69fac8fbd1852bd47f2891d92bc6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStartMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-start + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-start + """ + + def __init__(self): + super().__init__(LabelStart) + + def __get__(self, instance, owner=None) -> ( + 'LabelStartMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStart': + pass + + def __enter__(self) -> 'LabelStart': + pass + + +class LabelStart( + YANGContainer, + metaclass=LabelStartMeta): + """ + YANG container handler. + + YANG name: label-start + """ + + _yang_name: Final[str] = 'label-start' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelStartMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStart': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d3aeed125a790da60e394f9e834fb871ab9c3b9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStepMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-step + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-step + """ + + def __init__(self): + super().__init__(LabelStep) + + def __get__(self, instance, owner=None) -> ( + 'LabelStepMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStep': + pass + + def __enter__(self) -> 'LabelStep': + pass + + +class LabelStep( + YANGContainer, + metaclass=LabelStepMeta): + """ + YANG container handler. + + YANG name: label-step + """ + + _yang_name: Final[str] = 'label-step' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStep': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + LabelStepMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + LabelStepMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/label_restrictions/label_restriction/label_step/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8dbcffdcef6a5a8e5db53b62fce3a3f123ea450f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MaxLinkBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: max-link-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: max-link-bandwidth + """ + + def __init__(self): + super().__init__(MaxLinkBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'MaxLinkBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'MaxLinkBandwidth': + pass + + def __enter__(self) -> 'MaxLinkBandwidth': + pass + + +class MaxLinkBandwidth( + YANGContainer, + metaclass=MaxLinkBandwidthMeta): + """ + YANG container handler. + + YANG name: max-link-bandwidth + """ + + _yang_name: Final[str] = 'max-link-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + MaxLinkBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MaxLinkBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_link_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..92e8cf6bf3d3ec018101b740c97d4721224527f7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MaxResvLinkBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: max-resv-link-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: max-resv-link-bandwidth + """ + + def __init__(self): + super().__init__(MaxResvLinkBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'MaxResvLinkBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'MaxResvLinkBandwidth': + pass + + def __enter__(self) -> 'MaxResvLinkBandwidth': + pass + + +class MaxResvLinkBandwidth( + YANGContainer, + metaclass=MaxResvLinkBandwidthMeta): + """ + YANG container handler. + + YANG name: max-resv-link-bandwidth + """ + + _yang_name: Final[str] = 'max-resv-link-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + MaxResvLinkBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MaxResvLinkBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/max_resv_link_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/te_nsrlgs/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/te_nsrlgs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e5e97fc164047e8b36086ca3700f75d61848220c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/te_nsrlgs/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeNsrlgsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-nsrlgs + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-nsrlgs + """ + + def __init__(self): + super().__init__(TeNsrlgs) + + def __get__(self, instance, owner=None) -> ( + 'TeNsrlgsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeNsrlgs': + pass + + def __enter__(self) -> 'TeNsrlgs': + pass + + +class TeNsrlgs( + YANGContainer, + metaclass=TeNsrlgsMeta): + """ + YANG container handler. + + YANG name: te-nsrlgs + """ + + _yang_name: Final[str] = 'te-nsrlgs' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeNsrlgs': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/te_srlgs/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/te_srlgs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..561b31be827190ecd2cf49c88adb2118e8018b00 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/te_srlgs/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeSrlgsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-srlgs + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-srlgs + """ + + def __init__(self): + super().__init__(TeSrlgs) + + def __get__(self, instance, owner=None) -> ( + 'TeSrlgsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeSrlgs': + pass + + def __enter__(self) -> 'TeSrlgs': + pass + + +class TeSrlgs( + YANGContainer, + metaclass=TeSrlgsMeta): + """ + YANG container handler. + + YANG name: te-srlgs + """ + + _yang_name: Final[str] = 'te-srlgs' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeSrlgs': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fd4e9d8a913ee8fb4ba711c3d10310583ea16711 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnreservedBandwidthMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: unreserved-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: unreserved-bandwidth + """ + + def __init__(self): + super().__init__(UnreservedBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'UnreservedBandwidthMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['UnreservedBandwidth']: + pass + + def __iter__(self, key) -> Iterator['UnreservedBandwidth']: + return super().__iter__() + + def __getitem__(self, key) -> 'UnreservedBandwidth': + return super()[key] + + def __enter__(self) -> ( + 'UnreservedBandwidthMeta.yang_list_descriptor'): + pass + + +class UnreservedBandwidth( + YANGListItem, + metaclass=UnreservedBandwidthMeta): + """ + YANG list item handler. + + YANG name: unreserved-bandwidth + """ + + _yang_name: Final[str] = 'unreserved-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'priority', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'priority': ( + priority := YANGLeafMember( + 'priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + UnreservedBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnreservedBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_entry/unreserved_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_state/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_state/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..91fd095ce45cdfe4669215874ed2aeabfc57b835 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_state/__init__.py @@ -0,0 +1,104 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class InformationSourceStateMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: information-source-state + """ + from .topology import Topology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: information-source-state + """ + + def __init__(self): + super().__init__(InformationSourceState) + + def __get__(self, instance, owner=None) -> ( + 'InformationSourceStateMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'InformationSourceState': + pass + + def __enter__(self) -> 'InformationSourceState': + pass + + +class InformationSourceState( + YANGContainer, + metaclass=InformationSourceStateMeta): + """ + YANG container handler. + + YANG name: information-source-state + """ + + _yang_name: Final[str] = 'information-source-state' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'credibility-preference': ( + credibility_preference := YANGLeafMember( + 'credibility-preference', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'network-instance': ( + network_instance := YANGLeafMember( + 'network-instance', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'logical-network-element': ( + logical_network_element := YANGLeafMember( + 'logical-network-element', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'topology': ( + topology := ( # YANGContainerMember( + InformationSourceStateMeta. + Topology. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'InformationSourceState': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_state/topology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_state/topology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..63598ce3305f3b8b540d2d10d31cf66604ea175c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/information_source_state/topology/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TopologyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: topology + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: topology + """ + + def __init__(self): + super().__init__(Topology) + + def __get__(self, instance, owner=None) -> ( + 'TopologyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Topology': + pass + + def __enter__(self) -> 'Topology': + pass + + +class Topology( + YANGContainer, + metaclass=TopologyMeta): + """ + YANG container handler. + + YANG name: topology + """ + + _yang_name: Final[str] = 'topology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-ref': ( + link_ref := YANGLeafMember( + 'link-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Topology': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/recovery/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/recovery/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ecaf0b0c27bf56b948e42a76356e755c71ebf360 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/recovery/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RecoveryMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: recovery + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: recovery + """ + + def __init__(self): + super().__init__(Recovery) + + def __get__(self, instance, owner=None) -> ( + 'RecoveryMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Recovery': + pass + + def __enter__(self) -> 'Recovery': + pass + + +class Recovery( + YANGContainer, + metaclass=RecoveryMeta): + """ + YANG container handler. + + YANG name: recovery + """ + + _yang_name: Final[str] = 'recovery' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'restoration-status': ( + restoration_status := YANGLeafMember( + 'restoration-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'protection-status': ( + protection_status := YANGLeafMember( + 'protection-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Recovery': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/statistics/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/statistics/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..08e82ba9e2412515916a0d1c4aeb8cb819cf7ba8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/statistics/__init__.py @@ -0,0 +1,187 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class StatisticsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: statistics + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: statistics + """ + + def __init__(self): + super().__init__(Statistics) + + def __get__(self, instance, owner=None) -> ( + 'StatisticsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Statistics': + pass + + def __enter__(self) -> 'Statistics': + pass + + +class Statistics( + YANGContainer, + metaclass=StatisticsMeta): + """ + YANG container handler. + + YANG name: statistics + """ + + _yang_name: Final[str] = 'statistics' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'enables': ( + enables := YANGLeafMember( + 'enables', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'modifies': ( + modifies := YANGLeafMember( + 'modifies', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'fault-detects': ( + fault_detects := YANGLeafMember( + 'fault-detects', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restoration-failures': ( + restoration_failures := YANGLeafMember( + 'restoration-failures', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'protection-switches': ( + protection_switches := YANGLeafMember( + 'protection-switches', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'downs': ( + downs := YANGLeafMember( + 'downs', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restoration-successes': ( + restoration_successes := YANGLeafMember( + 'restoration-successes', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restoration-reversion-starts': ( + restoration_reversion_starts := YANGLeafMember( + 'restoration-reversion-starts', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'maintenance-clears': ( + maintenance_clears := YANGLeafMember( + 'maintenance-clears', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'protection-reverts': ( + protection_reverts := YANGLeafMember( + 'protection-reverts', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restoration-reversion-successes': ( + restoration_reversion_successes := YANGLeafMember( + 'restoration-reversion-successes', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'ups': ( + ups := YANGLeafMember( + 'ups', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restoration-starts': ( + restoration_starts := YANGLeafMember( + 'restoration-starts', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'discontinuity-time': ( + discontinuity_time := YANGLeafMember( + 'discontinuity-time', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'disables': ( + disables := YANGLeafMember( + 'disables', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'fault-clears': ( + fault_clears := YANGLeafMember( + 'fault-clears', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'maintenance-sets': ( + maintenance_sets := YANGLeafMember( + 'maintenance-sets', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restoration-reversion-failures': ( + restoration_reversion_failures := YANGLeafMember( + 'restoration-reversion-failures', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Statistics': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..706a755fae50b2e463f93632ba44e2dafcf21661 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/__init__.py @@ -0,0 +1,202 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLinkAttributesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-link-attributes + """ + from .max_resv_link_bandwidth import MaxResvLinkBandwidth + from .max_link_bandwidth import MaxLinkBandwidth + from .underlay import Underlay + from .te_srlgs import TeSrlgs + from .label_restrictions import LabelRestrictions + from .external_domain import ExternalDomain + from .te_nsrlgs import TeNsrlgs + from .unreserved_bandwidth import UnreservedBandwidth + from .interface_switching_capability import InterfaceSwitchingCapability + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-link-attributes + """ + + def __init__(self): + super().__init__(TeLinkAttributes) + + def __get__(self, instance, owner=None) -> ( + 'TeLinkAttributesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLinkAttributes': + pass + + def __enter__(self) -> 'TeLinkAttributes': + pass + + +class TeLinkAttributes( + YANGContainer, + metaclass=TeLinkAttributesMeta): + """ + YANG container handler. + + YANG name: te-link-attributes + """ + + _yang_name: Final[str] = 'te-link-attributes' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'is-abstract': ( + is_abstract := YANGLeafMember( + 'is-abstract', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-index': ( + link_index := YANGLeafMember( + 'link-index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'te-default-metric': ( + te_default_metric := YANGLeafMember( + 'te-default-metric', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-protection-type': ( + link_protection_type := YANGLeafMember( + 'link-protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'admin-status': ( + admin_status := YANGLeafMember( + 'admin-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'te-igp-metric': ( + te_igp_metric := YANGLeafMember( + 'te-igp-metric', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'access-type': ( + access_type := YANGLeafMember( + 'access-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'te-delay-metric': ( + te_delay_metric := YANGLeafMember( + 'te-delay-metric', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'administrative-group': ( + administrative_group := YANGLeafMember( + 'administrative-group', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'max-resv-link-bandwidth': ( + max_resv_link_bandwidth := ( # YANGContainerMember( + TeLinkAttributesMeta. + MaxResvLinkBandwidth. + yang_container_descriptor())), + + 'max-link-bandwidth': ( + max_link_bandwidth := ( # YANGContainerMember( + TeLinkAttributesMeta. + MaxLinkBandwidth. + yang_container_descriptor())), + + 'underlay': ( + underlay := ( # YANGContainerMember( + TeLinkAttributesMeta. + Underlay. + yang_container_descriptor())), + + 'te-srlgs': ( + te_srlgs := ( # YANGContainerMember( + TeLinkAttributesMeta. + TeSrlgs. + yang_container_descriptor())), + + 'label-restrictions': ( + label_restrictions := ( # YANGContainerMember( + TeLinkAttributesMeta. + LabelRestrictions. + yang_container_descriptor())), + + 'external-domain': ( + external_domain := ( # YANGContainerMember( + TeLinkAttributesMeta. + ExternalDomain. + yang_container_descriptor())), + + 'te-nsrlgs': ( + te_nsrlgs := ( # YANGContainerMember( + TeLinkAttributesMeta. + TeNsrlgs. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'unreserved-bandwidth': ( + unreserved_bandwidth := ( # YANGListMember( + TeLinkAttributesMeta. + UnreservedBandwidth. + yang_list_descriptor())), + + 'interface-switching-capability': ( + interface_switching_capability := ( # YANGListMember( + TeLinkAttributesMeta. + InterfaceSwitchingCapability. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLinkAttributes': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/external_domain/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/external_domain/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..58a1d9d4dcf0f87fa40fddfc379b3245219a8ef0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/external_domain/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExternalDomainMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: external-domain + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: external-domain + """ + + def __init__(self): + super().__init__(ExternalDomain) + + def __get__(self, instance, owner=None) -> ( + 'ExternalDomainMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExternalDomain': + pass + + def __enter__(self) -> 'ExternalDomain': + pass + + +class ExternalDomain( + YANGContainer, + metaclass=ExternalDomainMeta): + """ + YANG container handler. + + YANG name: external-domain + """ + + _yang_name: Final[str] = 'external-domain' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'remote-te-node-id': ( + remote_te_node_id := YANGLeafMember( + 'remote-te-node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'remote-te-link-tp-id': ( + remote_te_link_tp_id := YANGLeafMember( + 'remote-te-link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExternalDomain': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..42361e143910d3dc4963a100c961f548c4740f4a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/__init__.py @@ -0,0 +1,110 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class InterfaceSwitchingCapabilityMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: interface-switching-capability + """ + from .max_lsp_bandwidth import MaxLspBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: interface-switching-capability + """ + + def __init__(self): + super().__init__(InterfaceSwitchingCapability) + + def __get__(self, instance, owner=None) -> ( + 'InterfaceSwitchingCapabilityMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['InterfaceSwitchingCapability']: + pass + + def __iter__(self, key) -> Iterator['InterfaceSwitchingCapability']: + return super().__iter__() + + def __getitem__(self, key) -> 'InterfaceSwitchingCapability': + return super()[key] + + def __enter__(self) -> ( + 'InterfaceSwitchingCapabilityMeta.yang_list_descriptor'): + pass + + +class InterfaceSwitchingCapability( + YANGListItem, + metaclass=InterfaceSwitchingCapabilityMeta): + """ + YANG list item handler. + + YANG name: interface-switching-capability + """ + + _yang_name: Final[str] = 'interface-switching-capability' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'switching-capability', + 'encoding', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'switching-capability': ( + switching_capability := YANGLeafMember( + 'switching-capability', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'encoding': ( + encoding := YANGLeafMember( + 'encoding', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'max-lsp-bandwidth': ( + max_lsp_bandwidth := ( # YANGListMember( + InterfaceSwitchingCapabilityMeta. + MaxLspBandwidth. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'InterfaceSwitchingCapability': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ddad298bbc0cc7c626bd869965fe6da4630b6fb5 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MaxLspBandwidthMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: max-lsp-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: max-lsp-bandwidth + """ + + def __init__(self): + super().__init__(MaxLspBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'MaxLspBandwidthMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['MaxLspBandwidth']: + pass + + def __iter__(self, key) -> Iterator['MaxLspBandwidth']: + return super().__iter__() + + def __getitem__(self, key) -> 'MaxLspBandwidth': + return super()[key] + + def __enter__(self) -> ( + 'MaxLspBandwidthMeta.yang_list_descriptor'): + pass + + +class MaxLspBandwidth( + YANGListItem, + metaclass=MaxLspBandwidthMeta): + """ + YANG list item handler. + + YANG name: max-lsp-bandwidth + """ + + _yang_name: Final[str] = 'max-lsp-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'priority', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'priority': ( + priority := YANGLeafMember( + 'priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + MaxLspBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MaxLspBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29f30ca794c567238bb34de6d5de219f72b68cca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-restrictions + """ + from .label_restriction import LabelRestriction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-restrictions + """ + + def __init__(self): + super().__init__(LabelRestrictions) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelRestrictions': + pass + + def __enter__(self) -> 'LabelRestrictions': + pass + + +class LabelRestrictions( + YANGContainer, + metaclass=LabelRestrictionsMeta): + """ + YANG container handler. + + YANG name: label-restrictions + """ + + _yang_name: Final[str] = 'label-restrictions' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'label-restriction': ( + label_restriction := ( # YANGListMember( + LabelRestrictionsMeta. + LabelRestriction. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestrictions': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4a396a20af1746df44dc4e4f479436fde2d35e17 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: label-restriction + """ + from .label_start import LabelStart + from .label_step import LabelStep + from .label_end import LabelEnd + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: label-restriction + """ + + def __init__(self): + super().__init__(LabelRestriction) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LabelRestriction']: + pass + + def __iter__(self, key) -> Iterator['LabelRestriction']: + return super().__iter__() + + def __getitem__(self, key) -> 'LabelRestriction': + return super()[key] + + def __enter__(self) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + pass + + +class LabelRestriction( + YANGListItem, + metaclass=LabelRestrictionMeta): + """ + YANG list item handler. + + YANG name: label-restriction + """ + + _yang_name: Final[str] = 'label-restriction' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'range-bitmap': ( + range_bitmap := YANGLeafMember( + 'range-bitmap', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restriction': ( + restriction := YANGLeafMember( + 'restriction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-start': ( + label_start := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStart. + yang_container_descriptor())), + + 'label-step': ( + label_step := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStep. + yang_container_descriptor())), + + 'label-end': ( + label_end := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelEnd. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestriction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ad525773e032b7b224f5b661e728ffe8950e98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelEndMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-end + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-end + """ + + def __init__(self): + super().__init__(LabelEnd) + + def __get__(self, instance, owner=None) -> ( + 'LabelEndMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelEnd': + pass + + def __enter__(self) -> 'LabelEnd': + pass + + +class LabelEnd( + YANGContainer, + metaclass=LabelEndMeta): + """ + YANG container handler. + + YANG name: label-end + """ + + _yang_name: Final[str] = 'label-end' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelEndMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelEnd': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8985523ba0c69fac8fbd1852bd47f2891d92bc6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStartMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-start + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-start + """ + + def __init__(self): + super().__init__(LabelStart) + + def __get__(self, instance, owner=None) -> ( + 'LabelStartMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStart': + pass + + def __enter__(self) -> 'LabelStart': + pass + + +class LabelStart( + YANGContainer, + metaclass=LabelStartMeta): + """ + YANG container handler. + + YANG name: label-start + """ + + _yang_name: Final[str] = 'label-start' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelStartMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStart': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d3aeed125a790da60e394f9e834fb871ab9c3b9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStepMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-step + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-step + """ + + def __init__(self): + super().__init__(LabelStep) + + def __get__(self, instance, owner=None) -> ( + 'LabelStepMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStep': + pass + + def __enter__(self) -> 'LabelStep': + pass + + +class LabelStep( + YANGContainer, + metaclass=LabelStepMeta): + """ + YANG container handler. + + YANG name: label-step + """ + + _yang_name: Final[str] = 'label-step' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStep': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + LabelStepMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + LabelStepMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/label_restrictions/label_restriction/label_step/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8dbcffdcef6a5a8e5db53b62fce3a3f123ea450f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MaxLinkBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: max-link-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: max-link-bandwidth + """ + + def __init__(self): + super().__init__(MaxLinkBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'MaxLinkBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'MaxLinkBandwidth': + pass + + def __enter__(self) -> 'MaxLinkBandwidth': + pass + + +class MaxLinkBandwidth( + YANGContainer, + metaclass=MaxLinkBandwidthMeta): + """ + YANG container handler. + + YANG name: max-link-bandwidth + """ + + _yang_name: Final[str] = 'max-link-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + MaxLinkBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MaxLinkBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..92e8cf6bf3d3ec018101b740c97d4721224527f7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MaxResvLinkBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: max-resv-link-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: max-resv-link-bandwidth + """ + + def __init__(self): + super().__init__(MaxResvLinkBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'MaxResvLinkBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'MaxResvLinkBandwidth': + pass + + def __enter__(self) -> 'MaxResvLinkBandwidth': + pass + + +class MaxResvLinkBandwidth( + YANGContainer, + metaclass=MaxResvLinkBandwidthMeta): + """ + YANG container handler. + + YANG name: max-resv-link-bandwidth + """ + + _yang_name: Final[str] = 'max-resv-link-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + MaxResvLinkBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MaxResvLinkBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/te_nsrlgs/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/te_nsrlgs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e5e97fc164047e8b36086ca3700f75d61848220c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/te_nsrlgs/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeNsrlgsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-nsrlgs + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-nsrlgs + """ + + def __init__(self): + super().__init__(TeNsrlgs) + + def __get__(self, instance, owner=None) -> ( + 'TeNsrlgsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeNsrlgs': + pass + + def __enter__(self) -> 'TeNsrlgs': + pass + + +class TeNsrlgs( + YANGContainer, + metaclass=TeNsrlgsMeta): + """ + YANG container handler. + + YANG name: te-nsrlgs + """ + + _yang_name: Final[str] = 'te-nsrlgs' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeNsrlgs': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/te_srlgs/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/te_srlgs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..561b31be827190ecd2cf49c88adb2118e8018b00 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/te_srlgs/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeSrlgsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-srlgs + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-srlgs + """ + + def __init__(self): + super().__init__(TeSrlgs) + + def __get__(self, instance, owner=None) -> ( + 'TeSrlgsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeSrlgs': + pass + + def __enter__(self) -> 'TeSrlgs': + pass + + +class TeSrlgs( + YANGContainer, + metaclass=TeSrlgsMeta): + """ + YANG container handler. + + YANG name: te-srlgs + """ + + _yang_name: Final[str] = 'te-srlgs' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeSrlgs': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9ef388cd63aa7c8947fc3391bad703bb01f3d827 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/__init__.py @@ -0,0 +1,119 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay + """ + from .primary_path import PrimaryPath + from .tunnel_termination_points import TunnelTerminationPoints + from .tunnels import Tunnels + from .backup_path import BackupPath + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay + """ + + def __init__(self): + super().__init__(Underlay) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Underlay': + pass + + def __enter__(self) -> 'Underlay': + pass + + +class Underlay( + YANGContainer, + metaclass=UnderlayMeta): + """ + YANG container handler. + + YANG name: underlay + """ + + _yang_name: Final[str] = 'underlay' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'enabled': ( + enabled := YANGLeafMember( + 'enabled', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'protection-type': ( + protection_type := YANGLeafMember( + 'protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'primary-path': ( + primary_path := ( # YANGContainerMember( + UnderlayMeta. + PrimaryPath. + yang_container_descriptor())), + + 'tunnel-termination-points': ( + tunnel_termination_points := ( # YANGContainerMember( + UnderlayMeta. + TunnelTerminationPoints. + yang_container_descriptor())), + + 'tunnels': ( + tunnels := ( # YANGContainerMember( + UnderlayMeta. + Tunnels. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'backup-path': ( + backup_path := ( # YANGListMember( + UnderlayMeta. + BackupPath. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Underlay': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..eee438314ebe12c55dba835cf5f6839760a31c61 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/__init__.py @@ -0,0 +1,109 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BackupPathMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: backup-path + """ + from .path_element import PathElement + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: backup-path + """ + + def __init__(self): + super().__init__(BackupPath) + + def __get__(self, instance, owner=None) -> ( + 'BackupPathMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['BackupPath']: + pass + + def __iter__(self, key) -> Iterator['BackupPath']: + return super().__iter__() + + def __getitem__(self, key) -> 'BackupPath': + return super()[key] + + def __enter__(self) -> ( + 'BackupPathMeta.yang_list_descriptor'): + pass + + +class BackupPath( + YANGListItem, + metaclass=BackupPathMeta): + """ + YANG list item handler. + + YANG name: backup-path + """ + + _yang_name: Final[str] = 'backup-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + BackupPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'BackupPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..95deb32ec877a103436ef7b54fd1a23501216fab --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_link_hop import NumberedLinkHop + from .numbered_node_hop import NumberedNodeHop + from .label import Label + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1cb78075b80ccd8887818376324a016daf17b67c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..652da89e61bd32067e97591a11a2970e965bed4a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..34a2a729ce6d45e11174065699c428a7ac677a8b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PrimaryPathMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: primary-path + """ + from .path_element import PathElement + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: primary-path + """ + + def __init__(self): + super().__init__(PrimaryPath) + + def __get__(self, instance, owner=None) -> ( + 'PrimaryPathMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PrimaryPath': + pass + + def __enter__(self) -> 'PrimaryPath': + pass + + +class PrimaryPath( + YANGContainer, + metaclass=PrimaryPathMeta): + """ + YANG container handler. + + YANG name: primary-path + """ + + _yang_name: Final[str] = 'primary-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + PrimaryPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PrimaryPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6792cd8e4b1e1a843abf183eea400e13dbb78be --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .unnumbered_link_hop import UnnumberedLinkHop + from .numbered_link_hop import NumberedLinkHop + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + from .label import Label + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1abedb4d3f8145943387f3e66e3e17fed741dcdc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2aa767b55c350d6b4b7ec04998c04f5fa568d051 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c5cccf39482c3497e05c1c7ab8f4fdd3e2d7490b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/tunnel_termination_points/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelTerminationPointsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnel-termination-points + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnel-termination-points + """ + + def __init__(self): + super().__init__(TunnelTerminationPoints) + + def __get__(self, instance, owner=None) -> ( + 'TunnelTerminationPointsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TunnelTerminationPoints': + pass + + def __enter__(self) -> 'TunnelTerminationPoints': + pass + + +class TunnelTerminationPoints( + YANGContainer, + metaclass=TunnelTerminationPointsMeta): + """ + YANG container handler. + + YANG name: tunnel-termination-points + """ + + _yang_name: Final[str] = 'tunnel-termination-points' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'destination': ( + destination := YANGLeafMember( + 'destination', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'source': ( + source := YANGLeafMember( + 'source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TunnelTerminationPoints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..303858f3e0c28faecf9696d2fbf403d5510cced8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnels + """ + from .tunnel import Tunnel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnels + """ + + def __init__(self): + super().__init__(Tunnels) + + def __get__(self, instance, owner=None) -> ( + 'TunnelsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tunnels': + pass + + def __enter__(self) -> 'Tunnels': + pass + + +class Tunnels( + YANGContainer, + metaclass=TunnelsMeta): + """ + YANG container handler. + + YANG name: tunnels + """ + + _yang_name: Final[str] = 'tunnels' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tunnel': ( + tunnel := ( # YANGListMember( + TunnelsMeta. + Tunnel. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnels': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f854dfd329ce016317b7b9743ace874769f03094 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/underlay/tunnels/tunnel/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tunnel + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tunnel + """ + + def __init__(self): + super().__init__(Tunnel) + + def __get__(self, instance, owner=None) -> ( + 'TunnelMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tunnel']: + pass + + def __iter__(self, key) -> Iterator['Tunnel']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tunnel': + return super()[key] + + def __enter__(self) -> ( + 'TunnelMeta.yang_list_descriptor'): + pass + + +class Tunnel( + YANGListItem, + metaclass=TunnelMeta): + """ + YANG list item handler. + + YANG name: tunnel + """ + + _yang_name: Final[str] = 'tunnel' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tunnel-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'tunnel-name': ( + tunnel_name := YANGLeafMember( + 'tunnel-name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnel': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fd4e9d8a913ee8fb4ba711c3d10310583ea16711 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnreservedBandwidthMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: unreserved-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: unreserved-bandwidth + """ + + def __init__(self): + super().__init__(UnreservedBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'UnreservedBandwidthMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['UnreservedBandwidth']: + pass + + def __iter__(self, key) -> Iterator['UnreservedBandwidth']: + return super().__iter__() + + def __getitem__(self, key) -> 'UnreservedBandwidth': + return super()[key] + + def __enter__(self) -> ( + 'UnreservedBandwidthMeta.yang_list_descriptor'): + pass + + +class UnreservedBandwidth( + YANGListItem, + metaclass=UnreservedBandwidthMeta): + """ + YANG list item handler. + + YANG name: unreserved-bandwidth + """ + + _yang_name: Final[str] = 'unreserved-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'priority', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'priority': ( + priority := YANGLeafMember( + 'priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + UnreservedBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnreservedBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/underlay/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/underlay/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ea01121d057b002c61d31fe6f49e50049c04b952 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/link/te/underlay/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay + """ + + def __init__(self): + super().__init__(Underlay) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Underlay': + pass + + def __enter__(self) -> 'Underlay': + pass + + +class Underlay( + YANGContainer, + metaclass=UnderlayMeta): + """ + YANG container handler. + + YANG name: underlay + """ + + _yang_name: Final[str] = 'underlay' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'dynamic': ( + dynamic := YANGLeafMember( + 'dynamic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'committed': ( + committed := YANGLeafMember( + 'committed', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Underlay': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/network_types/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/network_types/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0fb174b74c14bff912498e9c690c949d93d2b76b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/network_types/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NetworkTypesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: network-types + """ + from .te_topology import TeTopology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: network-types + """ + + def __init__(self): + super().__init__(NetworkTypes) + + def __get__(self, instance, owner=None) -> ( + 'NetworkTypesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NetworkTypes': + pass + + def __enter__(self) -> 'NetworkTypes': + pass + + +class NetworkTypes( + YANGContainer, + metaclass=NetworkTypesMeta): + """ + YANG container handler. + + YANG name: network-types + """ + + _yang_name: Final[str] = 'network-types' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network' + _yang_module_name: Final[str] = 'ietf-network' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-topology': ( + te_topology := ( # YANGContainerMember( + NetworkTypesMeta. + TeTopology. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NetworkTypes': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/network_types/te_topology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/network_types/te_topology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d41731af61cc5a91e1178ed27ff7a5634149f15 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/network_types/te_topology/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeTopologyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-topology + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-topology + """ + + def __init__(self): + super().__init__(TeTopology) + + def __get__(self, instance, owner=None) -> ( + 'TeTopologyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeTopology': + pass + + def __enter__(self) -> 'TeTopology': + pass + + +class TeTopology( + YANGContainer, + metaclass=TeTopologyMeta): + """ + YANG container handler. + + YANG name: te-topology + """ + + _yang_name: Final[str] = 'te-topology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeTopology': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c6a31d9a0e3b49286b2df219900fc10df3c39c56 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/__init__.py @@ -0,0 +1,123 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NodeMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: node + """ + from .te import Te + from .termination_point import TerminationPoint + from .supporting_node import SupportingNode + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: node + """ + + def __init__(self): + super().__init__(Node) + + def __get__(self, instance, owner=None) -> ( + 'NodeMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Node']: + pass + + def __iter__(self, key) -> Iterator['Node']: + return super().__iter__() + + def __getitem__(self, key) -> 'Node': + return super()[key] + + def __enter__(self) -> ( + 'NodeMeta.yang_list_descriptor'): + pass + + +class Node( + YANGListItem, + metaclass=NodeMeta): + """ + YANG list item handler. + + YANG name: node + """ + + _yang_name: Final[str] = 'node' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network' + _yang_module_name: Final[str] = 'ietf-network' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'node-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'te-node-id': ( + te_node_id := YANGLeafMember( + 'te-node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-network', + 'ietf-network')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te': ( + te := ( # YANGContainerMember( + NodeMeta. + Te. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'termination-point': ( + termination_point := ( # YANGListMember( + NodeMeta. + TerminationPoint. + yang_list_descriptor())), + + 'supporting-node': ( + supporting_node := ( # YANGListMember( + NodeMeta. + SupportingNode. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Node': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/supporting_node/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/supporting_node/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..abeb4a984b9b0c939ae51217ac7144f568841550 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/supporting_node/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SupportingNodeMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: supporting-node + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: supporting-node + """ + + def __init__(self): + super().__init__(SupportingNode) + + def __get__(self, instance, owner=None) -> ( + 'SupportingNodeMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['SupportingNode']: + pass + + def __iter__(self, key) -> Iterator['SupportingNode']: + return super().__iter__() + + def __getitem__(self, key) -> 'SupportingNode': + return super()[key] + + def __enter__(self) -> ( + 'SupportingNodeMeta.yang_list_descriptor'): + pass + + +class SupportingNode( + YANGListItem, + metaclass=SupportingNodeMeta): + """ + YANG list item handler. + + YANG name: supporting-node + """ + + _yang_name: Final[str] = 'supporting-node' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network' + _yang_module_name: Final[str] = 'ietf-network' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'network-ref', + 'node-ref', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-network', + 'ietf-network')), + + 'node-ref': ( + node_ref := YANGLeafMember( + 'node-ref', + 'urn:ietf:params:xml:ns:yang:ietf-network', + 'ietf-network')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SupportingNode': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2ad66ed994421c34ac0e36ef0189e6f5a21b646f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/__init__.py @@ -0,0 +1,145 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te + """ + from .statistics import Statistics + from .geolocation import Geolocation + from .te_node_attributes import TeNodeAttributes + from .information_source_state import InformationSourceState + from .tunnel_termination_point import TunnelTerminationPoint + from .information_source_entry import InformationSourceEntry + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te + """ + + def __init__(self): + super().__init__(Te) + + def __get__(self, instance, owner=None) -> ( + 'TeMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Te': + pass + + def __enter__(self) -> 'Te': + pass + + +class Te( + YANGContainer, + metaclass=TeMeta): + """ + YANG container handler. + + YANG name: te + """ + + _yang_name: Final[str] = 'te' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'oper-status': ( + oper_status := YANGLeafMember( + 'oper-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'information-source': ( + information_source := YANGLeafMember( + 'information-source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'information-source-instance': ( + information_source_instance := YANGLeafMember( + 'information-source-instance', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'is-multi-access-dr': ( + is_multi_access_dr := YANGLeafMember( + 'is-multi-access-dr', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'statistics': ( + statistics := ( # YANGContainerMember( + TeMeta. + Statistics. + yang_container_descriptor())), + + 'geolocation': ( + geolocation := ( # YANGContainerMember( + TeMeta. + Geolocation. + yang_container_descriptor())), + + 'te-node-attributes': ( + te_node_attributes := ( # YANGContainerMember( + TeMeta. + TeNodeAttributes. + yang_container_descriptor())), + + 'information-source-state': ( + information_source_state := ( # YANGContainerMember( + TeMeta. + InformationSourceState. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tunnel-termination-point': ( + tunnel_termination_point := ( # YANGListMember( + TeMeta. + TunnelTerminationPoint. + yang_list_descriptor())), + + 'information-source-entry': ( + information_source_entry := ( # YANGListMember( + TeMeta. + InformationSourceEntry. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Te': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/geolocation/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/geolocation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5a631c3553d9ab5ce7b22b799dbf338a0f87fa43 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/geolocation/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GeolocationMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: geolocation + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: geolocation + """ + + def __init__(self): + super().__init__(Geolocation) + + def __get__(self, instance, owner=None) -> ( + 'GeolocationMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Geolocation': + pass + + def __enter__(self) -> 'Geolocation': + pass + + +class Geolocation( + YANGContainer, + metaclass=GeolocationMeta): + """ + YANG container handler. + + YANG name: geolocation + """ + + _yang_name: Final[str] = 'geolocation' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'latitude': ( + latitude := YANGLeafMember( + 'latitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'altitude': ( + altitude := YANGLeafMember( + 'altitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'longitude': ( + longitude := YANGLeafMember( + 'longitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Geolocation': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21bfe84df044875786766febf0915d7c70737106 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/__init__.py @@ -0,0 +1,142 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class InformationSourceEntryMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: information-source-entry + """ + from .information_source_state import InformationSourceState + from .underlay_topology import UnderlayTopology + from .connectivity_matrices import ConnectivityMatrices + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: information-source-entry + """ + + def __init__(self): + super().__init__(InformationSourceEntry) + + def __get__(self, instance, owner=None) -> ( + 'InformationSourceEntryMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['InformationSourceEntry']: + pass + + def __iter__(self, key) -> Iterator['InformationSourceEntry']: + return super().__iter__() + + def __getitem__(self, key) -> 'InformationSourceEntry': + return super()[key] + + def __enter__(self) -> ( + 'InformationSourceEntryMeta.yang_list_descriptor'): + pass + + +class InformationSourceEntry( + YANGListItem, + metaclass=InformationSourceEntryMeta): + """ + YANG list item handler. + + YANG name: information-source-entry + """ + + _yang_name: Final[str] = 'information-source-entry' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'information-source', + 'information-source-instance', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'information-source': ( + information_source := YANGLeafMember( + 'information-source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'domain-id': ( + domain_id := YANGLeafMember( + 'domain-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'is-abstract': ( + is_abstract := YANGLeafMember( + 'is-abstract', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'information-source-instance': ( + information_source_instance := YANGLeafMember( + 'information-source-instance', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'information-source-state': ( + information_source_state := ( # YANGContainerMember( + InformationSourceEntryMeta. + InformationSourceState. + yang_container_descriptor())), + + 'underlay-topology': ( + underlay_topology := ( # YANGContainerMember( + InformationSourceEntryMeta. + UnderlayTopology. + yang_container_descriptor())), + + 'connectivity-matrices': ( + connectivity_matrices := ( # YANGContainerMember( + InformationSourceEntryMeta. + ConnectivityMatrices. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'InformationSourceEntry': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..08c000d9b26dfa8e9c926a9ef5705a9e9fa0fa31 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/__init__.py @@ -0,0 +1,133 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ConnectivityMatricesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: connectivity-matrices + """ + from .path_properties import PathProperties + from .path_constraints import PathConstraints + from .optimizations import Optimizations + from .underlay import Underlay + from .label_restrictions import LabelRestrictions + from .connectivity_matrix import ConnectivityMatrix + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: connectivity-matrices + """ + + def __init__(self): + super().__init__(ConnectivityMatrices) + + def __get__(self, instance, owner=None) -> ( + 'ConnectivityMatricesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ConnectivityMatrices': + pass + + def __enter__(self) -> 'ConnectivityMatrices': + pass + + +class ConnectivityMatrices( + YANGContainer, + metaclass=ConnectivityMatricesMeta): + """ + YANG container handler. + + YANG name: connectivity-matrices + """ + + _yang_name: Final[str] = 'connectivity-matrices' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'number-of-entries': ( + number_of_entries := YANGLeafMember( + 'number-of-entries', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'is-allowed': ( + is_allowed := YANGLeafMember( + 'is-allowed', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-properties': ( + path_properties := ( # YANGContainerMember( + ConnectivityMatricesMeta. + PathProperties. + yang_container_descriptor())), + + 'path-constraints': ( + path_constraints := ( # YANGContainerMember( + ConnectivityMatricesMeta. + PathConstraints. + yang_container_descriptor())), + + 'optimizations': ( + optimizations := ( # YANGContainerMember( + ConnectivityMatricesMeta. + Optimizations. + yang_container_descriptor())), + + 'underlay': ( + underlay := ( # YANGContainerMember( + ConnectivityMatricesMeta. + Underlay. + yang_container_descriptor())), + + 'label-restrictions': ( + label_restrictions := ( # YANGContainerMember( + ConnectivityMatricesMeta. + LabelRestrictions. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'connectivity-matrix': ( + connectivity_matrix := ( # YANGListMember( + ConnectivityMatricesMeta. + ConnectivityMatrix. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ConnectivityMatrices': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bc57f620463762241042a9afbb5d5fa46368dc55 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/__init__.py @@ -0,0 +1,144 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ConnectivityMatrixMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: connectivity-matrix + """ + from .to import To + from .underlay import Underlay + from .path_properties import PathProperties + from .optimizations import Optimizations + from .from import From + from .path_constraints import PathConstraints + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: connectivity-matrix + """ + + def __init__(self): + super().__init__(ConnectivityMatrix) + + def __get__(self, instance, owner=None) -> ( + 'ConnectivityMatrixMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['ConnectivityMatrix']: + pass + + def __iter__(self, key) -> Iterator['ConnectivityMatrix']: + return super().__iter__() + + def __getitem__(self, key) -> 'ConnectivityMatrix': + return super()[key] + + def __enter__(self) -> ( + 'ConnectivityMatrixMeta.yang_list_descriptor'): + pass + + +class ConnectivityMatrix( + YANGListItem, + metaclass=ConnectivityMatrixMeta): + """ + YANG list item handler. + + YANG name: connectivity-matrix + """ + + _yang_name: Final[str] = 'connectivity-matrix' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'id': ( + id := YANGLeafMember( + 'id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'is-allowed': ( + is_allowed := YANGLeafMember( + 'is-allowed', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'to': ( + to := ( # YANGContainerMember( + ConnectivityMatrixMeta. + To. + yang_container_descriptor())), + + 'underlay': ( + underlay := ( # YANGContainerMember( + ConnectivityMatrixMeta. + Underlay. + yang_container_descriptor())), + + 'path-properties': ( + path_properties := ( # YANGContainerMember( + ConnectivityMatrixMeta. + PathProperties. + yang_container_descriptor())), + + 'optimizations': ( + optimizations := ( # YANGContainerMember( + ConnectivityMatrixMeta. + Optimizations. + yang_container_descriptor())), + + 'from': ( + from := ( # YANGContainerMember( + ConnectivityMatrixMeta. + From. + yang_container_descriptor())), + + 'path-constraints': ( + path_constraints := ( # YANGContainerMember( + ConnectivityMatrixMeta. + PathConstraints. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ConnectivityMatrix': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..14cbae7304f9e1b80e18a1547974269f00b66621 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class FromMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: from + """ + from .label_restrictions import LabelRestrictions + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: from + """ + + def __init__(self): + super().__init__(From) + + def __get__(self, instance, owner=None) -> ( + 'FromMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'From': + pass + + def __enter__(self) -> 'From': + pass + + +class From( + YANGContainer, + metaclass=FromMeta): + """ + YANG container handler. + + YANG name: from + """ + + _yang_name: Final[str] = 'from' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tp-ref': ( + tp_ref := YANGLeafMember( + 'tp-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-restrictions': ( + label_restrictions := ( # YANGContainerMember( + FromMeta. + LabelRestrictions. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'From': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29f30ca794c567238bb34de6d5de219f72b68cca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-restrictions + """ + from .label_restriction import LabelRestriction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-restrictions + """ + + def __init__(self): + super().__init__(LabelRestrictions) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelRestrictions': + pass + + def __enter__(self) -> 'LabelRestrictions': + pass + + +class LabelRestrictions( + YANGContainer, + metaclass=LabelRestrictionsMeta): + """ + YANG container handler. + + YANG name: label-restrictions + """ + + _yang_name: Final[str] = 'label-restrictions' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'label-restriction': ( + label_restriction := ( # YANGListMember( + LabelRestrictionsMeta. + LabelRestriction. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestrictions': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..86c3a10ff67557b730c7883f68f60a5220014139 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: label-restriction + """ + from .label_start import LabelStart + from .label_step import LabelStep + from .label_end import LabelEnd + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: label-restriction + """ + + def __init__(self): + super().__init__(LabelRestriction) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LabelRestriction']: + pass + + def __iter__(self, key) -> Iterator['LabelRestriction']: + return super().__iter__() + + def __getitem__(self, key) -> 'LabelRestriction': + return super()[key] + + def __enter__(self) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + pass + + +class LabelRestriction( + YANGListItem, + metaclass=LabelRestrictionMeta): + """ + YANG list item handler. + + YANG name: label-restriction + """ + + _yang_name: Final[str] = 'label-restriction' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'restriction': ( + restriction := YANGLeafMember( + 'restriction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'range-bitmap': ( + range_bitmap := YANGLeafMember( + 'range-bitmap', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-start': ( + label_start := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStart. + yang_container_descriptor())), + + 'label-step': ( + label_step := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStep. + yang_container_descriptor())), + + 'label-end': ( + label_end := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelEnd. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestriction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ad525773e032b7b224f5b661e728ffe8950e98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelEndMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-end + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-end + """ + + def __init__(self): + super().__init__(LabelEnd) + + def __get__(self, instance, owner=None) -> ( + 'LabelEndMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelEnd': + pass + + def __enter__(self) -> 'LabelEnd': + pass + + +class LabelEnd( + YANGContainer, + metaclass=LabelEndMeta): + """ + YANG container handler. + + YANG name: label-end + """ + + _yang_name: Final[str] = 'label-end' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelEndMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelEnd': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8985523ba0c69fac8fbd1852bd47f2891d92bc6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStartMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-start + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-start + """ + + def __init__(self): + super().__init__(LabelStart) + + def __get__(self, instance, owner=None) -> ( + 'LabelStartMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStart': + pass + + def __enter__(self) -> 'LabelStart': + pass + + +class LabelStart( + YANGContainer, + metaclass=LabelStartMeta): + """ + YANG container handler. + + YANG name: label-start + """ + + _yang_name: Final[str] = 'label-start' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelStartMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStart': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d3aeed125a790da60e394f9e834fb871ab9c3b9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStepMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-step + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-step + """ + + def __init__(self): + super().__init__(LabelStep) + + def __get__(self, instance, owner=None) -> ( + 'LabelStepMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStep': + pass + + def __enter__(self) -> 'LabelStep': + pass + + +class LabelStep( + YANGContainer, + metaclass=LabelStepMeta): + """ + YANG container handler. + + YANG name: label-step + """ + + _yang_name: Final[str] = 'label-step' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStep': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + LabelStepMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + LabelStepMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c8d4f4c8def0e90dabe399cc305dc3b8d3d500 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: optimizations + """ + from .algorithm import Algorithm + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: optimizations + """ + + def __init__(self): + super().__init__(Optimizations) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Optimizations': + pass + + def __enter__(self) -> 'Optimizations': + pass + + +class Optimizations( + YANGContainer, + metaclass=OptimizationsMeta): + """ + YANG container handler. + + YANG name: optimizations + """ + + _yang_name: Final[str] = 'optimizations' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Optimizations': + instance = super().__new__(cls) + instance._yang_choices = { + + 'algorithm': + OptimizationsMeta.Algorithm( + instance), + } + return instance + + @property + def algorithm(self) -> ( + OptimizationsMeta.Algorithm): + return self._yang_choices['algorithm'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9e0ca52a42ed25af1b7e0612d3e9a6b3d43b6ef9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/__init__.py @@ -0,0 +1,101 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AlgorithmMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: algorithm + """ + + from .objective_function import ObjectiveFunction + from .metric import Metric + + class objective_function_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.objective_function_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + class metric_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.Metric) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.metric_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + +class Algorithm(YANGChoice, metaclass=AlgorithmMeta): + """ + YANG choice handler. + + YANG name: algorithm + """ + + _yang_name: Final[str] = 'algorithm' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'objective-function': ( + objective_function := ( # YANGChoiceCase( + AlgorithmMeta. + objective_function_case_descriptor())), + + 'metric': ( + metric := ( # YANGChoiceCase( + AlgorithmMeta. + metric_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e7d1da8ee3719d0d6a3c401df7340fbd3517e8ed --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: metric + """ + from .tiebreakers import Tiebreakers + from .optimization_metric import OptimizationMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__(Metric) + + def __get__(self, instance, owner=None) -> ( + 'MetricMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Metric': + pass + + def __enter__(self) -> 'Metric': + pass + + +class Metric( + YANGContainer, + metaclass=MetricMeta): + """ + YANG container handler. + + YANG name: metric + """ + + _yang_name: Final[str] = 'metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'tiebreakers': ( + tiebreakers := ( # YANGContainerMember( + MetricMeta. + Tiebreakers. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'optimization-metric': ( + optimization_metric := ( # YANGListMember( + MetricMeta. + OptimizationMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Metric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e0b3f85a0993ca8184c4cec6a891f373b0666767 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/__init__.py @@ -0,0 +1,116 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: optimization-metric + """ + from .explicit_route_include_objects import ExplicitRouteIncludeObjects + from .explicit_route_exclude_objects import ExplicitRouteExcludeObjects + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: optimization-metric + """ + + def __init__(self): + super().__init__(OptimizationMetric) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['OptimizationMetric']: + pass + + def __iter__(self, key) -> Iterator['OptimizationMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'OptimizationMetric': + return super()[key] + + def __enter__(self) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + pass + + +class OptimizationMetric( + YANGListItem, + metaclass=OptimizationMetricMeta): + """ + YANG list item handler. + + YANG name: optimization-metric + """ + + _yang_name: Final[str] = 'optimization-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'weight': ( + weight := YANGLeafMember( + 'weight', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'explicit-route-include-objects': ( + explicit_route_include_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteIncludeObjects. + yang_container_descriptor())), + + 'explicit-route-exclude-objects': ( + explicit_route_exclude_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteExcludeObjects. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'OptimizationMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aea7bdd4cd5ed1743a1764899878a1ac8035348e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteExcludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + from .route_object_exclude_object import RouteObjectExcludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-exclude-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteExcludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteExcludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteExcludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteExcludeObjects': + pass + + +class ExplicitRouteExcludeObjects( + YANGContainer, + metaclass=ExplicitRouteExcludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + + _yang_name: Final[str] = 'explicit-route-exclude-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-exclude-object': ( + route_object_exclude_object := ( # YANGListMember( + ExplicitRouteExcludeObjectsMeta. + RouteObjectExcludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteExcludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..405906d3e6d9dd1eda79aae3a6302c37e0e24988 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectExcludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-exclude-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-exclude-object + """ + + def __init__(self): + super().__init__(RouteObjectExcludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectExcludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectExcludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectExcludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectExcludeObject( + YANGListItem, + metaclass=RouteObjectExcludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-exclude-object + """ + + _yang_name: Final[str] = 'route-object-exclude-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectExcludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectExcludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectExcludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e00223044020f31fddaff4d0a41e5b5c2c7181bc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py @@ -0,0 +1,217 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .unnumbered_link_hop import UnnumberedLinkHop + from .label import Label + from .numbered_link_hop import NumberedLinkHop + from .numbered_node_hop import NumberedNodeHop + from .as_number import AsNumber + from .srlg import Srlg + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class srlg_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__( + TypeMeta.Srlg) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.srlg_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Srlg'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Srlg'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'srlg': ( + srlg := ( # YANGChoiceCase( + TypeMeta. + srlg_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..64a8ec6d5e2fd4a77c59c13b3e37cacb001c91fe --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..420f996a13a20bf122ec87f0fbb109b34246eb61 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + from .srlg import Srlg + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'srlg': ( + srlg := ( # YANGContainerMember( + SrlgMeta. + Srlg. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..95a1628e4caf545e0d31823f89ea93178ffb76c7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'srlg': ( + srlg := YANGLeafMember( + 'srlg', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2aa767b55c350d6b4b7ec04998c04f5fa568d051 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3209b99bad73493077e9e91a8053f320b05c11c0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteIncludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-include-objects + """ + from .route_object_include_object import RouteObjectIncludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-include-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteIncludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteIncludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteIncludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteIncludeObjects': + pass + + +class ExplicitRouteIncludeObjects( + YANGContainer, + metaclass=ExplicitRouteIncludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-include-objects + """ + + _yang_name: Final[str] = 'explicit-route-include-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-include-object': ( + route_object_include_object := ( # YANGListMember( + ExplicitRouteIncludeObjectsMeta. + RouteObjectIncludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteIncludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c9f24330ff35e20e47be0db730f6ec682dd71d2d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectIncludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-include-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-include-object + """ + + def __init__(self): + super().__init__(RouteObjectIncludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectIncludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectIncludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectIncludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectIncludeObject( + YANGListItem, + metaclass=RouteObjectIncludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-include-object + """ + + _yang_name: Final[str] = 'route-object-include-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectIncludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectIncludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectIncludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..99085dad5868ea8d4f63c188ccd69653b0d7a1d4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .unnumbered_link_hop import UnnumberedLinkHop + from .numbered_link_hop import NumberedLinkHop + from .numbered_node_hop import NumberedNodeHop + from .label import Label + from .as_number import AsNumber + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c993df52db1f2e1aa1085a57856c8585fcba58 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2aa767b55c350d6b4b7ec04998c04f5fa568d051 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d345b57b342afaa50a04c5782794f34b810b795c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakersMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tiebreakers + """ + from .tiebreaker import Tiebreaker + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tiebreakers + """ + + def __init__(self): + super().__init__(Tiebreakers) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakersMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tiebreakers': + pass + + def __enter__(self) -> 'Tiebreakers': + pass + + +class Tiebreakers( + YANGContainer, + metaclass=TiebreakersMeta): + """ + YANG container handler. + + YANG name: tiebreakers + """ + + _yang_name: Final[str] = 'tiebreakers' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tiebreaker': ( + tiebreaker := ( # YANGListMember( + TiebreakersMeta. + Tiebreaker. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreakers': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..500d880ad6ad48b8079aa3bea0b1e644f7008f49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakerMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tiebreaker + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tiebreaker + """ + + def __init__(self): + super().__init__(Tiebreaker) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tiebreaker']: + pass + + def __iter__(self, key) -> Iterator['Tiebreaker']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tiebreaker': + return super()[key] + + def __enter__(self) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + pass + + +class Tiebreaker( + YANGListItem, + metaclass=TiebreakerMeta): + """ + YANG list item handler. + + YANG name: tiebreaker + """ + + _yang_name: Final[str] = 'tiebreaker' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tiebreaker-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tiebreaker-type': ( + tiebreaker_type := YANGLeafMember( + 'tiebreaker-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreaker': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbd32a2bb98c6e47f795103fbc122cbf7957e1e6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + from .objective_function import ObjectiveFunction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'objective-function': ( + objective_function := ( # YANGContainerMember( + ObjectiveFunctionMeta. + ObjectiveFunction. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..af72bcf2702ccee1d360bad39000241d1abfdc19 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/objective_function/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'objective-function-type': ( + objective_function_type := YANGLeafMember( + 'objective-function-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b473367cc49ea6b9b116af98e3d25cf058f70ffc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py @@ -0,0 +1,151 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-constraints + """ + from .te_bandwidth import TeBandwidth + from .path_srlgs_lists import PathSrlgsLists + from .path_srlgs_names import PathSrlgsNames + from .path_affinity_names import PathAffinityNames + from .path_metric_bounds import PathMetricBounds + from .path_affinities_values import PathAffinitiesValues + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-constraints + """ + + def __init__(self): + super().__init__(PathConstraints) + + def __get__(self, instance, owner=None) -> ( + 'PathConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathConstraints': + pass + + def __enter__(self) -> 'PathConstraints': + pass + + +class PathConstraints( + YANGContainer, + metaclass=PathConstraintsMeta): + """ + YANG container handler. + + YANG name: path-constraints + """ + + _yang_name: Final[str] = 'path-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hold-priority': ( + hold_priority := YANGLeafMember( + 'hold-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'setup-priority': ( + setup_priority := YANGLeafMember( + 'setup-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'signaling-type': ( + signaling_type := YANGLeafMember( + 'signaling-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'disjointness': ( + disjointness := YANGLeafMember( + 'disjointness', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-protection': ( + link_protection := YANGLeafMember( + 'link-protection', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + PathConstraintsMeta. + TeBandwidth. + yang_container_descriptor())), + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsNames. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinityNames. + yang_container_descriptor())), + + 'path-metric-bounds': ( + path_metric_bounds := ( # YANGContainerMember( + PathConstraintsMeta. + PathMetricBounds. + yang_container_descriptor())), + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinitiesValues. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d0e4a21b11accc2103aa85169cb46c386658d5cc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..356f7761b99b2e313b0638407dbaaa3996e6c418 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-metric-bounds + """ + from .path_metric_bound import PathMetricBound + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-metric-bounds + """ + + def __init__(self): + super().__init__(PathMetricBounds) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathMetricBounds': + pass + + def __enter__(self) -> 'PathMetricBounds': + pass + + +class PathMetricBounds( + YANGContainer, + metaclass=PathMetricBoundsMeta): + """ + YANG container handler. + + YANG name: path-metric-bounds + """ + + _yang_name: Final[str] = 'path-metric-bounds' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric-bound': ( + path_metric_bound := ( # YANGListMember( + PathMetricBoundsMeta. + PathMetricBound. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBounds': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2a97d5e3e1d7066756b051d139f997d9a46b3c6b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric-bound + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric-bound + """ + + def __init__(self): + super().__init__(PathMetricBound) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetricBound']: + pass + + def __iter__(self, key) -> Iterator['PathMetricBound']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetricBound': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + pass + + +class PathMetricBound( + YANGListItem, + metaclass=PathMetricBoundMeta): + """ + YANG list item handler. + + YANG name: path-metric-bound + """ + + _yang_name: Final[str] = 'path-metric-bound' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'upper-bound': ( + upper_bound := YANGLeafMember( + 'upper-bound', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBound': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..76541b227cefa1dca289ff8b4cc6350032acc02f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/__init__.py @@ -0,0 +1,121 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathPropertiesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-properties + """ + from .path_route_objects import PathRouteObjects + from .path_srlgs_names import PathSrlgsNames + from .path_srlgs_lists import PathSrlgsLists + from .path_affinities_values import PathAffinitiesValues + from .path_affinity_names import PathAffinityNames + from .path_metric import PathMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-properties + """ + + def __init__(self): + super().__init__(PathProperties) + + def __get__(self, instance, owner=None) -> ( + 'PathPropertiesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathProperties': + pass + + def __enter__(self) -> 'PathProperties': + pass + + +class PathProperties( + YANGContainer, + metaclass=PathPropertiesMeta): + """ + YANG container handler. + + YANG name: path-properties + """ + + _yang_name: Final[str] = 'path-properties' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-route-objects': ( + path_route_objects := ( # YANGContainerMember( + PathPropertiesMeta. + PathRouteObjects. + yang_container_descriptor())), + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsNames. + yang_container_descriptor())), + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinitiesValues. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinityNames. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric': ( + path_metric := ( # YANGListMember( + PathPropertiesMeta. + PathMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathProperties': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d0e4a21b11accc2103aa85169cb46c386658d5cc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d6ae074074e7913854992f9bd32a8f51f6b9d7b7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric + """ + + def __init__(self): + super().__init__(PathMetric) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetric']: + pass + + def __iter__(self, key) -> Iterator['PathMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetric': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricMeta.yang_list_descriptor'): + pass + + +class PathMetric( + YANGListItem, + metaclass=PathMetricMeta): + """ + YANG list item handler. + + YANG name: path-metric + """ + + _yang_name: Final[str] = 'path-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'accumulative-value': ( + accumulative_value := YANGLeafMember( + 'accumulative-value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2af8eb3f47d7b0ceb2d21f9f5b1ee44b432ab35f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-route-objects + """ + from .path_route_object import PathRouteObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-route-objects + """ + + def __init__(self): + super().__init__(PathRouteObjects) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathRouteObjects': + pass + + def __enter__(self) -> 'PathRouteObjects': + pass + + +class PathRouteObjects( + YANGContainer, + metaclass=PathRouteObjectsMeta): + """ + YANG container handler. + + YANG name: path-route-objects + """ + + _yang_name: Final[str] = 'path-route-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-route-object': ( + path_route_object := ( # YANGListMember( + PathRouteObjectsMeta. + PathRouteObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..74b9e21c769902d7a2bb1f362d2e95cbf5d862cd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-route-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-route-object + """ + + def __init__(self): + super().__init__(PathRouteObject) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathRouteObject']: + pass + + def __iter__(self, key) -> Iterator['PathRouteObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathRouteObject': + return super()[key] + + def __enter__(self) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + pass + + +class PathRouteObject( + YANGListItem, + metaclass=PathRouteObjectMeta): + """ + YANG list item handler. + + YANG name: path-route-object + """ + + _yang_name: Final[str] = 'path-route-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathRouteObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathRouteObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8bc2d82e13718733c4ed76acde67b8508071d571 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .unnumbered_link_hop import UnnumberedLinkHop + from .label import Label + from .numbered_link_hop import NumberedLinkHop + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8d9d3d58559fab79fa12a634fb4aecbef61780f1 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3a6876e61b9d99b8ed5b00bc13f60857e8fb3d76 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d03118f5c94e3726341c4332447847c61623d616 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ToMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: to + """ + from .label_restrictions import LabelRestrictions + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: to + """ + + def __init__(self): + super().__init__(To) + + def __get__(self, instance, owner=None) -> ( + 'ToMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'To': + pass + + def __enter__(self) -> 'To': + pass + + +class To( + YANGContainer, + metaclass=ToMeta): + """ + YANG container handler. + + YANG name: to + """ + + _yang_name: Final[str] = 'to' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tp-ref': ( + tp_ref := YANGLeafMember( + 'tp-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-restrictions': ( + label_restrictions := ( # YANGContainerMember( + ToMeta. + LabelRestrictions. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'To': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29f30ca794c567238bb34de6d5de219f72b68cca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-restrictions + """ + from .label_restriction import LabelRestriction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-restrictions + """ + + def __init__(self): + super().__init__(LabelRestrictions) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelRestrictions': + pass + + def __enter__(self) -> 'LabelRestrictions': + pass + + +class LabelRestrictions( + YANGContainer, + metaclass=LabelRestrictionsMeta): + """ + YANG container handler. + + YANG name: label-restrictions + """ + + _yang_name: Final[str] = 'label-restrictions' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'label-restriction': ( + label_restriction := ( # YANGListMember( + LabelRestrictionsMeta. + LabelRestriction. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestrictions': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..61cb67d4bdc9682e1228c9cb9ddfb86817c96f62 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: label-restriction + """ + from .label_end import LabelEnd + from .label_start import LabelStart + from .label_step import LabelStep + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: label-restriction + """ + + def __init__(self): + super().__init__(LabelRestriction) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LabelRestriction']: + pass + + def __iter__(self, key) -> Iterator['LabelRestriction']: + return super().__iter__() + + def __getitem__(self, key) -> 'LabelRestriction': + return super()[key] + + def __enter__(self) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + pass + + +class LabelRestriction( + YANGListItem, + metaclass=LabelRestrictionMeta): + """ + YANG list item handler. + + YANG name: label-restriction + """ + + _yang_name: Final[str] = 'label-restriction' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'range-bitmap': ( + range_bitmap := YANGLeafMember( + 'range-bitmap', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restriction': ( + restriction := YANGLeafMember( + 'restriction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-end': ( + label_end := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelEnd. + yang_container_descriptor())), + + 'label-start': ( + label_start := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStart. + yang_container_descriptor())), + + 'label-step': ( + label_step := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStep. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestriction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ad525773e032b7b224f5b661e728ffe8950e98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelEndMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-end + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-end + """ + + def __init__(self): + super().__init__(LabelEnd) + + def __get__(self, instance, owner=None) -> ( + 'LabelEndMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelEnd': + pass + + def __enter__(self) -> 'LabelEnd': + pass + + +class LabelEnd( + YANGContainer, + metaclass=LabelEndMeta): + """ + YANG container handler. + + YANG name: label-end + """ + + _yang_name: Final[str] = 'label-end' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelEndMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelEnd': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8985523ba0c69fac8fbd1852bd47f2891d92bc6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStartMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-start + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-start + """ + + def __init__(self): + super().__init__(LabelStart) + + def __get__(self, instance, owner=None) -> ( + 'LabelStartMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStart': + pass + + def __enter__(self) -> 'LabelStart': + pass + + +class LabelStart( + YANGContainer, + metaclass=LabelStartMeta): + """ + YANG container handler. + + YANG name: label-start + """ + + _yang_name: Final[str] = 'label-start' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelStartMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStart': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d3aeed125a790da60e394f9e834fb871ab9c3b9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStepMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-step + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-step + """ + + def __init__(self): + super().__init__(LabelStep) + + def __get__(self, instance, owner=None) -> ( + 'LabelStepMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStep': + pass + + def __enter__(self) -> 'LabelStep': + pass + + +class LabelStep( + YANGContainer, + metaclass=LabelStepMeta): + """ + YANG container handler. + + YANG name: label-step + """ + + _yang_name: Final[str] = 'label-step' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStep': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + LabelStepMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + LabelStepMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2feb9b8f1d3512055ea66c91d1dfc9059e8cf901 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/__init__.py @@ -0,0 +1,119 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay + """ + from .primary_path import PrimaryPath + from .tunnels import Tunnels + from .tunnel_termination_points import TunnelTerminationPoints + from .backup_path import BackupPath + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay + """ + + def __init__(self): + super().__init__(Underlay) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Underlay': + pass + + def __enter__(self) -> 'Underlay': + pass + + +class Underlay( + YANGContainer, + metaclass=UnderlayMeta): + """ + YANG container handler. + + YANG name: underlay + """ + + _yang_name: Final[str] = 'underlay' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'protection-type': ( + protection_type := YANGLeafMember( + 'protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'enabled': ( + enabled := YANGLeafMember( + 'enabled', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'primary-path': ( + primary_path := ( # YANGContainerMember( + UnderlayMeta. + PrimaryPath. + yang_container_descriptor())), + + 'tunnels': ( + tunnels := ( # YANGContainerMember( + UnderlayMeta. + Tunnels. + yang_container_descriptor())), + + 'tunnel-termination-points': ( + tunnel_termination_points := ( # YANGContainerMember( + UnderlayMeta. + TunnelTerminationPoints. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'backup-path': ( + backup_path := ( # YANGListMember( + UnderlayMeta. + BackupPath. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Underlay': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..eee438314ebe12c55dba835cf5f6839760a31c61 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py @@ -0,0 +1,109 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BackupPathMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: backup-path + """ + from .path_element import PathElement + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: backup-path + """ + + def __init__(self): + super().__init__(BackupPath) + + def __get__(self, instance, owner=None) -> ( + 'BackupPathMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['BackupPath']: + pass + + def __iter__(self, key) -> Iterator['BackupPath']: + return super().__iter__() + + def __getitem__(self, key) -> 'BackupPath': + return super()[key] + + def __enter__(self) -> ( + 'BackupPathMeta.yang_list_descriptor'): + pass + + +class BackupPath( + YANGListItem, + metaclass=BackupPathMeta): + """ + YANG list item handler. + + YANG name: backup-path + """ + + _yang_name: Final[str] = 'backup-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + BackupPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'BackupPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..077e86df002f4bbdf6f8b1a9767746e1493b8fc4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .label import Label + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .numbered_link_hop import NumberedLinkHop + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..64a8ec6d5e2fd4a77c59c13b3e37cacb001c91fe --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..00c674167360cd2724dd7263e34c54dbb27dbccb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..34a2a729ce6d45e11174065699c428a7ac677a8b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PrimaryPathMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: primary-path + """ + from .path_element import PathElement + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: primary-path + """ + + def __init__(self): + super().__init__(PrimaryPath) + + def __get__(self, instance, owner=None) -> ( + 'PrimaryPathMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PrimaryPath': + pass + + def __enter__(self) -> 'PrimaryPath': + pass + + +class PrimaryPath( + YANGContainer, + metaclass=PrimaryPathMeta): + """ + YANG container handler. + + YANG name: primary-path + """ + + _yang_name: Final[str] = 'primary-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + PrimaryPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PrimaryPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a2076e54c3ca2f4e75844db6a7ca736e6a1cc6ce --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .label import Label + from .numbered_link_hop import NumberedLinkHop + from .numbered_node_hop import NumberedNodeHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c993df52db1f2e1aa1085a57856c8585fcba58 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e568286bdabfa9cd970ff66b3e9b6a807b0f31f3 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c5cccf39482c3497e05c1c7ab8f4fdd3e2d7490b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelTerminationPointsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnel-termination-points + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnel-termination-points + """ + + def __init__(self): + super().__init__(TunnelTerminationPoints) + + def __get__(self, instance, owner=None) -> ( + 'TunnelTerminationPointsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TunnelTerminationPoints': + pass + + def __enter__(self) -> 'TunnelTerminationPoints': + pass + + +class TunnelTerminationPoints( + YANGContainer, + metaclass=TunnelTerminationPointsMeta): + """ + YANG container handler. + + YANG name: tunnel-termination-points + """ + + _yang_name: Final[str] = 'tunnel-termination-points' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'destination': ( + destination := YANGLeafMember( + 'destination', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'source': ( + source := YANGLeafMember( + 'source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TunnelTerminationPoints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..303858f3e0c28faecf9696d2fbf403d5510cced8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnels + """ + from .tunnel import Tunnel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnels + """ + + def __init__(self): + super().__init__(Tunnels) + + def __get__(self, instance, owner=None) -> ( + 'TunnelsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tunnels': + pass + + def __enter__(self) -> 'Tunnels': + pass + + +class Tunnels( + YANGContainer, + metaclass=TunnelsMeta): + """ + YANG container handler. + + YANG name: tunnels + """ + + _yang_name: Final[str] = 'tunnels' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tunnel': ( + tunnel := ( # YANGListMember( + TunnelsMeta. + Tunnel. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnels': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f854dfd329ce016317b7b9743ace874769f03094 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tunnel + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tunnel + """ + + def __init__(self): + super().__init__(Tunnel) + + def __get__(self, instance, owner=None) -> ( + 'TunnelMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tunnel']: + pass + + def __iter__(self, key) -> Iterator['Tunnel']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tunnel': + return super()[key] + + def __enter__(self) -> ( + 'TunnelMeta.yang_list_descriptor'): + pass + + +class Tunnel( + YANGListItem, + metaclass=TunnelMeta): + """ + YANG list item handler. + + YANG name: tunnel + """ + + _yang_name: Final[str] = 'tunnel' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tunnel-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'tunnel-name': ( + tunnel_name := YANGLeafMember( + 'tunnel-name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnel': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29f30ca794c567238bb34de6d5de219f72b68cca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-restrictions + """ + from .label_restriction import LabelRestriction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-restrictions + """ + + def __init__(self): + super().__init__(LabelRestrictions) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelRestrictions': + pass + + def __enter__(self) -> 'LabelRestrictions': + pass + + +class LabelRestrictions( + YANGContainer, + metaclass=LabelRestrictionsMeta): + """ + YANG container handler. + + YANG name: label-restrictions + """ + + _yang_name: Final[str] = 'label-restrictions' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'label-restriction': ( + label_restriction := ( # YANGListMember( + LabelRestrictionsMeta. + LabelRestriction. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestrictions': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..32c30d13361c09cf5f2a51b8e1e645103a430a6a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: label-restriction + """ + from .label_step import LabelStep + from .label_start import LabelStart + from .label_end import LabelEnd + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: label-restriction + """ + + def __init__(self): + super().__init__(LabelRestriction) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LabelRestriction']: + pass + + def __iter__(self, key) -> Iterator['LabelRestriction']: + return super().__iter__() + + def __getitem__(self, key) -> 'LabelRestriction': + return super()[key] + + def __enter__(self) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + pass + + +class LabelRestriction( + YANGListItem, + metaclass=LabelRestrictionMeta): + """ + YANG list item handler. + + YANG name: label-restriction + """ + + _yang_name: Final[str] = 'label-restriction' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restriction': ( + restriction := YANGLeafMember( + 'restriction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'range-bitmap': ( + range_bitmap := YANGLeafMember( + 'range-bitmap', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-step': ( + label_step := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStep. + yang_container_descriptor())), + + 'label-start': ( + label_start := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStart. + yang_container_descriptor())), + + 'label-end': ( + label_end := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelEnd. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestriction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ad525773e032b7b224f5b661e728ffe8950e98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelEndMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-end + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-end + """ + + def __init__(self): + super().__init__(LabelEnd) + + def __get__(self, instance, owner=None) -> ( + 'LabelEndMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelEnd': + pass + + def __enter__(self) -> 'LabelEnd': + pass + + +class LabelEnd( + YANGContainer, + metaclass=LabelEndMeta): + """ + YANG container handler. + + YANG name: label-end + """ + + _yang_name: Final[str] = 'label-end' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelEndMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelEnd': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8985523ba0c69fac8fbd1852bd47f2891d92bc6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStartMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-start + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-start + """ + + def __init__(self): + super().__init__(LabelStart) + + def __get__(self, instance, owner=None) -> ( + 'LabelStartMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStart': + pass + + def __enter__(self) -> 'LabelStart': + pass + + +class LabelStart( + YANGContainer, + metaclass=LabelStartMeta): + """ + YANG container handler. + + YANG name: label-start + """ + + _yang_name: Final[str] = 'label-start' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelStartMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStart': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d3aeed125a790da60e394f9e834fb871ab9c3b9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStepMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-step + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-step + """ + + def __init__(self): + super().__init__(LabelStep) + + def __get__(self, instance, owner=None) -> ( + 'LabelStepMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStep': + pass + + def __enter__(self) -> 'LabelStep': + pass + + +class LabelStep( + YANGContainer, + metaclass=LabelStepMeta): + """ + YANG container handler. + + YANG name: label-step + """ + + _yang_name: Final[str] = 'label-step' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStep': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + LabelStepMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + LabelStepMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c8d4f4c8def0e90dabe399cc305dc3b8d3d500 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: optimizations + """ + from .algorithm import Algorithm + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: optimizations + """ + + def __init__(self): + super().__init__(Optimizations) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Optimizations': + pass + + def __enter__(self) -> 'Optimizations': + pass + + +class Optimizations( + YANGContainer, + metaclass=OptimizationsMeta): + """ + YANG container handler. + + YANG name: optimizations + """ + + _yang_name: Final[str] = 'optimizations' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Optimizations': + instance = super().__new__(cls) + instance._yang_choices = { + + 'algorithm': + OptimizationsMeta.Algorithm( + instance), + } + return instance + + @property + def algorithm(self) -> ( + OptimizationsMeta.Algorithm): + return self._yang_choices['algorithm'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d82c7bf9c5ec990484589d660738ffe3d2d9f6bf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/__init__.py @@ -0,0 +1,101 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AlgorithmMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: algorithm + """ + + from .metric import Metric + from .objective_function import ObjectiveFunction + + class metric_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.Metric) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.metric_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + class objective_function_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.objective_function_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + +class Algorithm(YANGChoice, metaclass=AlgorithmMeta): + """ + YANG choice handler. + + YANG name: algorithm + """ + + _yang_name: Final[str] = 'algorithm' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'metric': ( + metric := ( # YANGChoiceCase( + AlgorithmMeta. + metric_case_descriptor())), + + 'objective-function': ( + objective_function := ( # YANGChoiceCase( + AlgorithmMeta. + objective_function_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e7d1da8ee3719d0d6a3c401df7340fbd3517e8ed --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: metric + """ + from .tiebreakers import Tiebreakers + from .optimization_metric import OptimizationMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__(Metric) + + def __get__(self, instance, owner=None) -> ( + 'MetricMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Metric': + pass + + def __enter__(self) -> 'Metric': + pass + + +class Metric( + YANGContainer, + metaclass=MetricMeta): + """ + YANG container handler. + + YANG name: metric + """ + + _yang_name: Final[str] = 'metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'tiebreakers': ( + tiebreakers := ( # YANGContainerMember( + MetricMeta. + Tiebreakers. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'optimization-metric': ( + optimization_metric := ( # YANGListMember( + MetricMeta. + OptimizationMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Metric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bad2331fc0f109b98bda93287a822244302b5d1e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/__init__.py @@ -0,0 +1,116 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: optimization-metric + """ + from .explicit_route_exclude_objects import ExplicitRouteExcludeObjects + from .explicit_route_include_objects import ExplicitRouteIncludeObjects + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: optimization-metric + """ + + def __init__(self): + super().__init__(OptimizationMetric) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['OptimizationMetric']: + pass + + def __iter__(self, key) -> Iterator['OptimizationMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'OptimizationMetric': + return super()[key] + + def __enter__(self) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + pass + + +class OptimizationMetric( + YANGListItem, + metaclass=OptimizationMetricMeta): + """ + YANG list item handler. + + YANG name: optimization-metric + """ + + _yang_name: Final[str] = 'optimization-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'weight': ( + weight := YANGLeafMember( + 'weight', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'explicit-route-exclude-objects': ( + explicit_route_exclude_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteExcludeObjects. + yang_container_descriptor())), + + 'explicit-route-include-objects': ( + explicit_route_include_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteIncludeObjects. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'OptimizationMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aea7bdd4cd5ed1743a1764899878a1ac8035348e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteExcludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + from .route_object_exclude_object import RouteObjectExcludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-exclude-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteExcludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteExcludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteExcludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteExcludeObjects': + pass + + +class ExplicitRouteExcludeObjects( + YANGContainer, + metaclass=ExplicitRouteExcludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + + _yang_name: Final[str] = 'explicit-route-exclude-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-exclude-object': ( + route_object_exclude_object := ( # YANGListMember( + ExplicitRouteExcludeObjectsMeta. + RouteObjectExcludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteExcludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..405906d3e6d9dd1eda79aae3a6302c37e0e24988 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectExcludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-exclude-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-exclude-object + """ + + def __init__(self): + super().__init__(RouteObjectExcludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectExcludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectExcludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectExcludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectExcludeObject( + YANGListItem, + metaclass=RouteObjectExcludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-exclude-object + """ + + _yang_name: Final[str] = 'route-object-exclude-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectExcludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectExcludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectExcludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8411b9056a87031a8a5453bd7ef0d46324215a2f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py @@ -0,0 +1,217 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + from .numbered_link_hop import NumberedLinkHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .label import Label + from .srlg import Srlg + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class srlg_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__( + TypeMeta.Srlg) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.srlg_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Srlg'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Srlg'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'srlg': ( + srlg := ( # YANGChoiceCase( + TypeMeta. + srlg_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8837ea16f120b8d9f40ee5099f46294b6ab79579 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..420f996a13a20bf122ec87f0fbb109b34246eb61 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + from .srlg import Srlg + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'srlg': ( + srlg := ( # YANGContainerMember( + SrlgMeta. + Srlg. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..95a1628e4caf545e0d31823f89ea93178ffb76c7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'srlg': ( + srlg := YANGLeafMember( + 'srlg', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..07c0b7b779289a6ac9a9123fd540526dc6d190fb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3209b99bad73493077e9e91a8053f320b05c11c0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteIncludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-include-objects + """ + from .route_object_include_object import RouteObjectIncludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-include-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteIncludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteIncludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteIncludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteIncludeObjects': + pass + + +class ExplicitRouteIncludeObjects( + YANGContainer, + metaclass=ExplicitRouteIncludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-include-objects + """ + + _yang_name: Final[str] = 'explicit-route-include-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-include-object': ( + route_object_include_object := ( # YANGListMember( + ExplicitRouteIncludeObjectsMeta. + RouteObjectIncludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteIncludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c9f24330ff35e20e47be0db730f6ec682dd71d2d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectIncludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-include-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-include-object + """ + + def __init__(self): + super().__init__(RouteObjectIncludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectIncludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectIncludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectIncludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectIncludeObject( + YANGListItem, + metaclass=RouteObjectIncludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-include-object + """ + + _yang_name: Final[str] = 'route-object-include-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectIncludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectIncludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectIncludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..70317d31c9d8ee9d772e58c135569168cf8843f7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + from .numbered_link_hop import NumberedLinkHop + from .label import Label + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1abedb4d3f8145943387f3e66e3e17fed741dcdc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aa5135a1afed60270d2606ad4c7ad19b66f70d7c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d345b57b342afaa50a04c5782794f34b810b795c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakersMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tiebreakers + """ + from .tiebreaker import Tiebreaker + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tiebreakers + """ + + def __init__(self): + super().__init__(Tiebreakers) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakersMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tiebreakers': + pass + + def __enter__(self) -> 'Tiebreakers': + pass + + +class Tiebreakers( + YANGContainer, + metaclass=TiebreakersMeta): + """ + YANG container handler. + + YANG name: tiebreakers + """ + + _yang_name: Final[str] = 'tiebreakers' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tiebreaker': ( + tiebreaker := ( # YANGListMember( + TiebreakersMeta. + Tiebreaker. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreakers': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..500d880ad6ad48b8079aa3bea0b1e644f7008f49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakerMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tiebreaker + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tiebreaker + """ + + def __init__(self): + super().__init__(Tiebreaker) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tiebreaker']: + pass + + def __iter__(self, key) -> Iterator['Tiebreaker']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tiebreaker': + return super()[key] + + def __enter__(self) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + pass + + +class Tiebreaker( + YANGListItem, + metaclass=TiebreakerMeta): + """ + YANG list item handler. + + YANG name: tiebreaker + """ + + _yang_name: Final[str] = 'tiebreaker' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tiebreaker-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tiebreaker-type': ( + tiebreaker_type := YANGLeafMember( + 'tiebreaker-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreaker': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbd32a2bb98c6e47f795103fbc122cbf7957e1e6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/objective_function/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + from .objective_function import ObjectiveFunction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'objective-function': ( + objective_function := ( # YANGContainerMember( + ObjectiveFunctionMeta. + ObjectiveFunction. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/objective_function/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/objective_function/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..af72bcf2702ccee1d360bad39000241d1abfdc19 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/optimizations/algorithm/objective_function/objective_function/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'objective-function-type': ( + objective_function_type := YANGLeafMember( + 'objective-function-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b600b1aeaf464f293a697c09c163096f730379f2 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/__init__.py @@ -0,0 +1,151 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-constraints + """ + from .te_bandwidth import TeBandwidth + from .path_metric_bounds import PathMetricBounds + from .path_affinities_values import PathAffinitiesValues + from .path_srlgs_lists import PathSrlgsLists + from .path_affinity_names import PathAffinityNames + from .path_srlgs_names import PathSrlgsNames + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-constraints + """ + + def __init__(self): + super().__init__(PathConstraints) + + def __get__(self, instance, owner=None) -> ( + 'PathConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathConstraints': + pass + + def __enter__(self) -> 'PathConstraints': + pass + + +class PathConstraints( + YANGContainer, + metaclass=PathConstraintsMeta): + """ + YANG container handler. + + YANG name: path-constraints + """ + + _yang_name: Final[str] = 'path-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hold-priority': ( + hold_priority := YANGLeafMember( + 'hold-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-protection': ( + link_protection := YANGLeafMember( + 'link-protection', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'disjointness': ( + disjointness := YANGLeafMember( + 'disjointness', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'setup-priority': ( + setup_priority := YANGLeafMember( + 'setup-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'signaling-type': ( + signaling_type := YANGLeafMember( + 'signaling-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + PathConstraintsMeta. + TeBandwidth. + yang_container_descriptor())), + + 'path-metric-bounds': ( + path_metric_bounds := ( # YANGContainerMember( + PathConstraintsMeta. + PathMetricBounds. + yang_container_descriptor())), + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinitiesValues. + yang_container_descriptor())), + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinityNames. + yang_container_descriptor())), + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsNames. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7560d7f51b4174c036b96d1a6599a2a3ada8d674 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..356f7761b99b2e313b0638407dbaaa3996e6c418 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-metric-bounds + """ + from .path_metric_bound import PathMetricBound + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-metric-bounds + """ + + def __init__(self): + super().__init__(PathMetricBounds) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathMetricBounds': + pass + + def __enter__(self) -> 'PathMetricBounds': + pass + + +class PathMetricBounds( + YANGContainer, + metaclass=PathMetricBoundsMeta): + """ + YANG container handler. + + YANG name: path-metric-bounds + """ + + _yang_name: Final[str] = 'path-metric-bounds' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric-bound': ( + path_metric_bound := ( # YANGListMember( + PathMetricBoundsMeta. + PathMetricBound. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBounds': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6e72a44fd364b7d9238cef98eba888090a23f76 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric-bound + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric-bound + """ + + def __init__(self): + super().__init__(PathMetricBound) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetricBound']: + pass + + def __iter__(self, key) -> Iterator['PathMetricBound']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetricBound': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + pass + + +class PathMetricBound( + YANGListItem, + metaclass=PathMetricBoundMeta): + """ + YANG list item handler. + + YANG name: path-metric-bound + """ + + _yang_name: Final[str] = 'path-metric-bound' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'upper-bound': ( + upper_bound := YANGLeafMember( + 'upper-bound', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBound': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_constraints/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..149786798cff216d2d5c3159b457969263950a72 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/__init__.py @@ -0,0 +1,121 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathPropertiesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-properties + """ + from .path_affinities_values import PathAffinitiesValues + from .path_route_objects import PathRouteObjects + from .path_srlgs_lists import PathSrlgsLists + from .path_affinity_names import PathAffinityNames + from .path_srlgs_names import PathSrlgsNames + from .path_metric import PathMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-properties + """ + + def __init__(self): + super().__init__(PathProperties) + + def __get__(self, instance, owner=None) -> ( + 'PathPropertiesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathProperties': + pass + + def __enter__(self) -> 'PathProperties': + pass + + +class PathProperties( + YANGContainer, + metaclass=PathPropertiesMeta): + """ + YANG container handler. + + YANG name: path-properties + """ + + _yang_name: Final[str] = 'path-properties' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinitiesValues. + yang_container_descriptor())), + + 'path-route-objects': ( + path_route_objects := ( # YANGContainerMember( + PathPropertiesMeta. + PathRouteObjects. + yang_container_descriptor())), + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinityNames. + yang_container_descriptor())), + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsNames. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric': ( + path_metric := ( # YANGListMember( + PathPropertiesMeta. + PathMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathProperties': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7560d7f51b4174c036b96d1a6599a2a3ada8d674 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7645abedd4d25aeb9c77aa579c2972a450d00a6e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_metric/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric + """ + + def __init__(self): + super().__init__(PathMetric) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetric']: + pass + + def __iter__(self, key) -> Iterator['PathMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetric': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricMeta.yang_list_descriptor'): + pass + + +class PathMetric( + YANGListItem, + metaclass=PathMetricMeta): + """ + YANG list item handler. + + YANG name: path-metric + """ + + _yang_name: Final[str] = 'path-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'accumulative-value': ( + accumulative_value := YANGLeafMember( + 'accumulative-value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2af8eb3f47d7b0ceb2d21f9f5b1ee44b432ab35f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-route-objects + """ + from .path_route_object import PathRouteObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-route-objects + """ + + def __init__(self): + super().__init__(PathRouteObjects) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathRouteObjects': + pass + + def __enter__(self) -> 'PathRouteObjects': + pass + + +class PathRouteObjects( + YANGContainer, + metaclass=PathRouteObjectsMeta): + """ + YANG container handler. + + YANG name: path-route-objects + """ + + _yang_name: Final[str] = 'path-route-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-route-object': ( + path_route_object := ( # YANGListMember( + PathRouteObjectsMeta. + PathRouteObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..74b9e21c769902d7a2bb1f362d2e95cbf5d862cd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-route-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-route-object + """ + + def __init__(self): + super().__init__(PathRouteObject) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathRouteObject']: + pass + + def __iter__(self, key) -> Iterator['PathRouteObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathRouteObject': + return super()[key] + + def __enter__(self) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + pass + + +class PathRouteObject( + YANGListItem, + metaclass=PathRouteObjectMeta): + """ + YANG list item handler. + + YANG name: path-route-object + """ + + _yang_name: Final[str] = 'path-route-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathRouteObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathRouteObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..535505eea9d601de2d3ee70ab7061cbcf2e35bc8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .label import Label + from .numbered_node_hop import NumberedNodeHop + from .as_number import AsNumber + from .unnumbered_link_hop import UnnumberedLinkHop + from .numbered_link_hop import NumberedLinkHop + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1abedb4d3f8145943387f3e66e3e17fed741dcdc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0f8e113b567402f37aecdf644dae003b86cc8bb4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ac722c47add5d381fef94d2c3a2f5750b49a2688 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/__init__.py @@ -0,0 +1,119 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay + """ + from .tunnels import Tunnels + from .tunnel_termination_points import TunnelTerminationPoints + from .primary_path import PrimaryPath + from .backup_path import BackupPath + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay + """ + + def __init__(self): + super().__init__(Underlay) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Underlay': + pass + + def __enter__(self) -> 'Underlay': + pass + + +class Underlay( + YANGContainer, + metaclass=UnderlayMeta): + """ + YANG container handler. + + YANG name: underlay + """ + + _yang_name: Final[str] = 'underlay' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'enabled': ( + enabled := YANGLeafMember( + 'enabled', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'protection-type': ( + protection_type := YANGLeafMember( + 'protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'tunnels': ( + tunnels := ( # YANGContainerMember( + UnderlayMeta. + Tunnels. + yang_container_descriptor())), + + 'tunnel-termination-points': ( + tunnel_termination_points := ( # YANGContainerMember( + UnderlayMeta. + TunnelTerminationPoints. + yang_container_descriptor())), + + 'primary-path': ( + primary_path := ( # YANGContainerMember( + UnderlayMeta. + PrimaryPath. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'backup-path': ( + backup_path := ( # YANGListMember( + UnderlayMeta. + BackupPath. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Underlay': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..eee438314ebe12c55dba835cf5f6839760a31c61 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/__init__.py @@ -0,0 +1,109 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BackupPathMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: backup-path + """ + from .path_element import PathElement + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: backup-path + """ + + def __init__(self): + super().__init__(BackupPath) + + def __get__(self, instance, owner=None) -> ( + 'BackupPathMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['BackupPath']: + pass + + def __iter__(self, key) -> Iterator['BackupPath']: + return super().__iter__() + + def __getitem__(self, key) -> 'BackupPath': + return super()[key] + + def __enter__(self) -> ( + 'BackupPathMeta.yang_list_descriptor'): + pass + + +class BackupPath( + YANGListItem, + metaclass=BackupPathMeta): + """ + YANG list item handler. + + YANG name: backup-path + """ + + _yang_name: Final[str] = 'backup-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + BackupPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'BackupPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3762dccee93d6c5fc548fea761a80e03cd0398d6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_node_hop import NumberedNodeHop + from .as_number import AsNumber + from .numbered_link_hop import NumberedLinkHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .label import Label + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c993df52db1f2e1aa1085a57856c8585fcba58 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..00c674167360cd2724dd7263e34c54dbb27dbccb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..34a2a729ce6d45e11174065699c428a7ac677a8b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PrimaryPathMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: primary-path + """ + from .path_element import PathElement + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: primary-path + """ + + def __init__(self): + super().__init__(PrimaryPath) + + def __get__(self, instance, owner=None) -> ( + 'PrimaryPathMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PrimaryPath': + pass + + def __enter__(self) -> 'PrimaryPath': + pass + + +class PrimaryPath( + YANGContainer, + metaclass=PrimaryPathMeta): + """ + YANG container handler. + + YANG name: primary-path + """ + + _yang_name: Final[str] = 'primary-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + PrimaryPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PrimaryPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d1ab68ff674ea58adde5a644c74609928fe6f874 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_node_hop import NumberedNodeHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + from .label import Label + from .numbered_link_hop import NumberedLinkHop + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8d9d3d58559fab79fa12a634fb4aecbef61780f1 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c909481cb8745c1895e9d6bcb7fb53fa10296f40 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8ae8cc268f3c4fc331cd1e1018be41d113da9183 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnel_termination_points/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelTerminationPointsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnel-termination-points + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnel-termination-points + """ + + def __init__(self): + super().__init__(TunnelTerminationPoints) + + def __get__(self, instance, owner=None) -> ( + 'TunnelTerminationPointsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TunnelTerminationPoints': + pass + + def __enter__(self) -> 'TunnelTerminationPoints': + pass + + +class TunnelTerminationPoints( + YANGContainer, + metaclass=TunnelTerminationPointsMeta): + """ + YANG container handler. + + YANG name: tunnel-termination-points + """ + + _yang_name: Final[str] = 'tunnel-termination-points' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'source': ( + source := YANGLeafMember( + 'source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'destination': ( + destination := YANGLeafMember( + 'destination', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TunnelTerminationPoints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..303858f3e0c28faecf9696d2fbf403d5510cced8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnels + """ + from .tunnel import Tunnel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnels + """ + + def __init__(self): + super().__init__(Tunnels) + + def __get__(self, instance, owner=None) -> ( + 'TunnelsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tunnels': + pass + + def __enter__(self) -> 'Tunnels': + pass + + +class Tunnels( + YANGContainer, + metaclass=TunnelsMeta): + """ + YANG container handler. + + YANG name: tunnels + """ + + _yang_name: Final[str] = 'tunnels' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tunnel': ( + tunnel := ( # YANGListMember( + TunnelsMeta. + Tunnel. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnels': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d36aa35acd17db473e177b143afdec573f0b4927 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/connectivity_matrices/underlay/tunnels/tunnel/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tunnel + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tunnel + """ + + def __init__(self): + super().__init__(Tunnel) + + def __get__(self, instance, owner=None) -> ( + 'TunnelMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tunnel']: + pass + + def __iter__(self, key) -> Iterator['Tunnel']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tunnel': + return super()[key] + + def __enter__(self) -> ( + 'TunnelMeta.yang_list_descriptor'): + pass + + +class Tunnel( + YANGListItem, + metaclass=TunnelMeta): + """ + YANG list item handler. + + YANG name: tunnel + """ + + _yang_name: Final[str] = 'tunnel' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tunnel-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tunnel-name': ( + tunnel_name := YANGLeafMember( + 'tunnel-name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnel': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/information_source_state/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/information_source_state/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..26d315f6a43287274e5b410c83c64a950c07014d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/information_source_state/__init__.py @@ -0,0 +1,104 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class InformationSourceStateMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: information-source-state + """ + from .topology import Topology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: information-source-state + """ + + def __init__(self): + super().__init__(InformationSourceState) + + def __get__(self, instance, owner=None) -> ( + 'InformationSourceStateMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'InformationSourceState': + pass + + def __enter__(self) -> 'InformationSourceState': + pass + + +class InformationSourceState( + YANGContainer, + metaclass=InformationSourceStateMeta): + """ + YANG container handler. + + YANG name: information-source-state + """ + + _yang_name: Final[str] = 'information-source-state' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-instance': ( + network_instance := YANGLeafMember( + 'network-instance', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'credibility-preference': ( + credibility_preference := YANGLeafMember( + 'credibility-preference', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'logical-network-element': ( + logical_network_element := YANGLeafMember( + 'logical-network-element', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'topology': ( + topology := ( # YANGContainerMember( + InformationSourceStateMeta. + Topology. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'InformationSourceState': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/information_source_state/topology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/information_source_state/topology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9e09ccdff8c5f951521b350308c3922079bad836 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/information_source_state/topology/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TopologyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: topology + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: topology + """ + + def __init__(self): + super().__init__(Topology) + + def __get__(self, instance, owner=None) -> ( + 'TopologyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Topology': + pass + + def __enter__(self) -> 'Topology': + pass + + +class Topology( + YANGContainer, + metaclass=TopologyMeta): + """ + YANG container handler. + + YANG name: topology + """ + + _yang_name: Final[str] = 'topology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-ref': ( + node_ref := YANGLeafMember( + 'node-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Topology': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/underlay_topology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/underlay_topology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..42dee7a72fe4a5d79128cf6ad278af68094e6692 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_entry/underlay_topology/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayTopologyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay-topology + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay-topology + """ + + def __init__(self): + super().__init__(UnderlayTopology) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayTopologyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnderlayTopology': + pass + + def __enter__(self) -> 'UnderlayTopology': + pass + + +class UnderlayTopology( + YANGContainer, + metaclass=UnderlayTopologyMeta): + """ + YANG container handler. + + YANG name: underlay-topology + """ + + _yang_name: Final[str] = 'underlay-topology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnderlayTopology': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_state/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_state/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6d2edeb71cbf031bc1516862b7175c9ed004e9a0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_state/__init__.py @@ -0,0 +1,104 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class InformationSourceStateMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: information-source-state + """ + from .topology import Topology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: information-source-state + """ + + def __init__(self): + super().__init__(InformationSourceState) + + def __get__(self, instance, owner=None) -> ( + 'InformationSourceStateMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'InformationSourceState': + pass + + def __enter__(self) -> 'InformationSourceState': + pass + + +class InformationSourceState( + YANGContainer, + metaclass=InformationSourceStateMeta): + """ + YANG container handler. + + YANG name: information-source-state + """ + + _yang_name: Final[str] = 'information-source-state' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'logical-network-element': ( + logical_network_element := YANGLeafMember( + 'logical-network-element', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'credibility-preference': ( + credibility_preference := YANGLeafMember( + 'credibility-preference', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'network-instance': ( + network_instance := YANGLeafMember( + 'network-instance', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'topology': ( + topology := ( # YANGContainerMember( + InformationSourceStateMeta. + Topology. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'InformationSourceState': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_state/topology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_state/topology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9e09ccdff8c5f951521b350308c3922079bad836 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/information_source_state/topology/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TopologyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: topology + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: topology + """ + + def __init__(self): + super().__init__(Topology) + + def __get__(self, instance, owner=None) -> ( + 'TopologyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Topology': + pass + + def __enter__(self) -> 'Topology': + pass + + +class Topology( + YANGContainer, + metaclass=TopologyMeta): + """ + YANG container handler. + + YANG name: topology + """ + + _yang_name: Final[str] = 'topology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-ref': ( + node_ref := YANGLeafMember( + 'node-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Topology': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/statistics/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/statistics/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5c42b5a651c746140109908a98c5d411f7b354b4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/statistics/__init__.py @@ -0,0 +1,99 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class StatisticsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: statistics + """ + from .node import Node + from .connectivity_matrix_entry import ConnectivityMatrixEntry + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: statistics + """ + + def __init__(self): + super().__init__(Statistics) + + def __get__(self, instance, owner=None) -> ( + 'StatisticsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Statistics': + pass + + def __enter__(self) -> 'Statistics': + pass + + +class Statistics( + YANGContainer, + metaclass=StatisticsMeta): + """ + YANG container handler. + + YANG name: statistics + """ + + _yang_name: Final[str] = 'statistics' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'discontinuity-time': ( + discontinuity_time := YANGLeafMember( + 'discontinuity-time', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'node': ( + node := ( # YANGContainerMember( + StatisticsMeta. + Node. + yang_container_descriptor())), + + 'connectivity-matrix-entry': ( + connectivity_matrix_entry := ( # YANGContainerMember( + StatisticsMeta. + ConnectivityMatrixEntry. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Statistics': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/statistics/connectivity_matrix_entry/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/statistics/connectivity_matrix_entry/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7ae31f705e9a8fa0e6bb6614787e440ad5d86410 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/statistics/connectivity_matrix_entry/__init__.py @@ -0,0 +1,109 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ConnectivityMatrixEntryMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: connectivity-matrix-entry + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: connectivity-matrix-entry + """ + + def __init__(self): + super().__init__(ConnectivityMatrixEntry) + + def __get__(self, instance, owner=None) -> ( + 'ConnectivityMatrixEntryMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ConnectivityMatrixEntry': + pass + + def __enter__(self) -> 'ConnectivityMatrixEntry': + pass + + +class ConnectivityMatrixEntry( + YANGContainer, + metaclass=ConnectivityMatrixEntryMeta): + """ + YANG container handler. + + YANG name: connectivity-matrix-entry + """ + + _yang_name: Final[str] = 'connectivity-matrix-entry' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'enables': ( + enables := YANGLeafMember( + 'enables', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'modifies': ( + modifies := YANGLeafMember( + 'modifies', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'creates': ( + creates := YANGLeafMember( + 'creates', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'disables': ( + disables := YANGLeafMember( + 'disables', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'deletes': ( + deletes := YANGLeafMember( + 'deletes', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ConnectivityMatrixEntry': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/statistics/node/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/statistics/node/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c56ab2444397767e1a021bf9158d0f3ccad1a088 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/statistics/node/__init__.py @@ -0,0 +1,109 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NodeMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: node + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: node + """ + + def __init__(self): + super().__init__(Node) + + def __get__(self, instance, owner=None) -> ( + 'NodeMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Node': + pass + + def __enter__(self) -> 'Node': + pass + + +class Node( + YANGContainer, + metaclass=NodeMeta): + """ + YANG container handler. + + YANG name: node + """ + + _yang_name: Final[str] = 'node' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'enables': ( + enables := YANGLeafMember( + 'enables', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'maintenance-clears': ( + maintenance_clears := YANGLeafMember( + 'maintenance-clears', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'disables': ( + disables := YANGLeafMember( + 'disables', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'maintenance-sets': ( + maintenance_sets := YANGLeafMember( + 'maintenance-sets', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'modifies': ( + modifies := YANGLeafMember( + 'modifies', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Node': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d34072811b1c72f6894141790ae68180723d5b09 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/__init__.py @@ -0,0 +1,117 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeNodeAttributesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-node-attributes + """ + from .connectivity_matrices import ConnectivityMatrices + from .underlay_topology import UnderlayTopology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-node-attributes + """ + + def __init__(self): + super().__init__(TeNodeAttributes) + + def __get__(self, instance, owner=None) -> ( + 'TeNodeAttributesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeNodeAttributes': + pass + + def __enter__(self) -> 'TeNodeAttributes': + pass + + +class TeNodeAttributes( + YANGContainer, + metaclass=TeNodeAttributesMeta): + """ + YANG container handler. + + YANG name: te-node-attributes + """ + + _yang_name: Final[str] = 'te-node-attributes' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'domain-id': ( + domain_id := YANGLeafMember( + 'domain-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'is-abstract': ( + is_abstract := YANGLeafMember( + 'is-abstract', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'admin-status': ( + admin_status := YANGLeafMember( + 'admin-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'connectivity-matrices': ( + connectivity_matrices := ( # YANGContainerMember( + TeNodeAttributesMeta. + ConnectivityMatrices. + yang_container_descriptor())), + + 'underlay-topology': ( + underlay_topology := ( # YANGContainerMember( + TeNodeAttributesMeta. + UnderlayTopology. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeNodeAttributes': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b6cae8709d65455d297c24861f6fd52badff4745 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/__init__.py @@ -0,0 +1,133 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ConnectivityMatricesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: connectivity-matrices + """ + from .label_restrictions import LabelRestrictions + from .optimizations import Optimizations + from .underlay import Underlay + from .path_properties import PathProperties + from .path_constraints import PathConstraints + from .connectivity_matrix import ConnectivityMatrix + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: connectivity-matrices + """ + + def __init__(self): + super().__init__(ConnectivityMatrices) + + def __get__(self, instance, owner=None) -> ( + 'ConnectivityMatricesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ConnectivityMatrices': + pass + + def __enter__(self) -> 'ConnectivityMatrices': + pass + + +class ConnectivityMatrices( + YANGContainer, + metaclass=ConnectivityMatricesMeta): + """ + YANG container handler. + + YANG name: connectivity-matrices + """ + + _yang_name: Final[str] = 'connectivity-matrices' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'number-of-entries': ( + number_of_entries := YANGLeafMember( + 'number-of-entries', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'is-allowed': ( + is_allowed := YANGLeafMember( + 'is-allowed', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-restrictions': ( + label_restrictions := ( # YANGContainerMember( + ConnectivityMatricesMeta. + LabelRestrictions. + yang_container_descriptor())), + + 'optimizations': ( + optimizations := ( # YANGContainerMember( + ConnectivityMatricesMeta. + Optimizations. + yang_container_descriptor())), + + 'underlay': ( + underlay := ( # YANGContainerMember( + ConnectivityMatricesMeta. + Underlay. + yang_container_descriptor())), + + 'path-properties': ( + path_properties := ( # YANGContainerMember( + ConnectivityMatricesMeta. + PathProperties. + yang_container_descriptor())), + + 'path-constraints': ( + path_constraints := ( # YANGContainerMember( + ConnectivityMatricesMeta. + PathConstraints. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'connectivity-matrix': ( + connectivity_matrix := ( # YANGListMember( + ConnectivityMatricesMeta. + ConnectivityMatrix. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ConnectivityMatrices': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..caf8d26a9e2be21ed0d3b862f36049fb6a191df9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/__init__.py @@ -0,0 +1,144 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ConnectivityMatrixMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: connectivity-matrix + """ + from .to import To + from .path_properties import PathProperties + from .underlay import Underlay + from .path_constraints import PathConstraints + from .from import From + from .optimizations import Optimizations + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: connectivity-matrix + """ + + def __init__(self): + super().__init__(ConnectivityMatrix) + + def __get__(self, instance, owner=None) -> ( + 'ConnectivityMatrixMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['ConnectivityMatrix']: + pass + + def __iter__(self, key) -> Iterator['ConnectivityMatrix']: + return super().__iter__() + + def __getitem__(self, key) -> 'ConnectivityMatrix': + return super()[key] + + def __enter__(self) -> ( + 'ConnectivityMatrixMeta.yang_list_descriptor'): + pass + + +class ConnectivityMatrix( + YANGListItem, + metaclass=ConnectivityMatrixMeta): + """ + YANG list item handler. + + YANG name: connectivity-matrix + """ + + _yang_name: Final[str] = 'connectivity-matrix' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'id': ( + id := YANGLeafMember( + 'id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'is-allowed': ( + is_allowed := YANGLeafMember( + 'is-allowed', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'to': ( + to := ( # YANGContainerMember( + ConnectivityMatrixMeta. + To. + yang_container_descriptor())), + + 'path-properties': ( + path_properties := ( # YANGContainerMember( + ConnectivityMatrixMeta. + PathProperties. + yang_container_descriptor())), + + 'underlay': ( + underlay := ( # YANGContainerMember( + ConnectivityMatrixMeta. + Underlay. + yang_container_descriptor())), + + 'path-constraints': ( + path_constraints := ( # YANGContainerMember( + ConnectivityMatrixMeta. + PathConstraints. + yang_container_descriptor())), + + 'from': ( + from := ( # YANGContainerMember( + ConnectivityMatrixMeta. + From. + yang_container_descriptor())), + + 'optimizations': ( + optimizations := ( # YANGContainerMember( + ConnectivityMatrixMeta. + Optimizations. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ConnectivityMatrix': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..14cbae7304f9e1b80e18a1547974269f00b66621 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class FromMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: from + """ + from .label_restrictions import LabelRestrictions + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: from + """ + + def __init__(self): + super().__init__(From) + + def __get__(self, instance, owner=None) -> ( + 'FromMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'From': + pass + + def __enter__(self) -> 'From': + pass + + +class From( + YANGContainer, + metaclass=FromMeta): + """ + YANG container handler. + + YANG name: from + """ + + _yang_name: Final[str] = 'from' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tp-ref': ( + tp_ref := YANGLeafMember( + 'tp-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-restrictions': ( + label_restrictions := ( # YANGContainerMember( + FromMeta. + LabelRestrictions. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'From': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29f30ca794c567238bb34de6d5de219f72b68cca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-restrictions + """ + from .label_restriction import LabelRestriction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-restrictions + """ + + def __init__(self): + super().__init__(LabelRestrictions) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelRestrictions': + pass + + def __enter__(self) -> 'LabelRestrictions': + pass + + +class LabelRestrictions( + YANGContainer, + metaclass=LabelRestrictionsMeta): + """ + YANG container handler. + + YANG name: label-restrictions + """ + + _yang_name: Final[str] = 'label-restrictions' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'label-restriction': ( + label_restriction := ( # YANGListMember( + LabelRestrictionsMeta. + LabelRestriction. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestrictions': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..90d6fbfa8ef329a23ca16908801c5dfc1c509b01 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: label-restriction + """ + from .label_end import LabelEnd + from .label_step import LabelStep + from .label_start import LabelStart + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: label-restriction + """ + + def __init__(self): + super().__init__(LabelRestriction) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LabelRestriction']: + pass + + def __iter__(self, key) -> Iterator['LabelRestriction']: + return super().__iter__() + + def __getitem__(self, key) -> 'LabelRestriction': + return super()[key] + + def __enter__(self) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + pass + + +class LabelRestriction( + YANGListItem, + metaclass=LabelRestrictionMeta): + """ + YANG list item handler. + + YANG name: label-restriction + """ + + _yang_name: Final[str] = 'label-restriction' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'range-bitmap': ( + range_bitmap := YANGLeafMember( + 'range-bitmap', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restriction': ( + restriction := YANGLeafMember( + 'restriction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-end': ( + label_end := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelEnd. + yang_container_descriptor())), + + 'label-step': ( + label_step := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStep. + yang_container_descriptor())), + + 'label-start': ( + label_start := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStart. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestriction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ad525773e032b7b224f5b661e728ffe8950e98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelEndMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-end + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-end + """ + + def __init__(self): + super().__init__(LabelEnd) + + def __get__(self, instance, owner=None) -> ( + 'LabelEndMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelEnd': + pass + + def __enter__(self) -> 'LabelEnd': + pass + + +class LabelEnd( + YANGContainer, + metaclass=LabelEndMeta): + """ + YANG container handler. + + YANG name: label-end + """ + + _yang_name: Final[str] = 'label-end' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelEndMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelEnd': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8985523ba0c69fac8fbd1852bd47f2891d92bc6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStartMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-start + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-start + """ + + def __init__(self): + super().__init__(LabelStart) + + def __get__(self, instance, owner=None) -> ( + 'LabelStartMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStart': + pass + + def __enter__(self) -> 'LabelStart': + pass + + +class LabelStart( + YANGContainer, + metaclass=LabelStartMeta): + """ + YANG container handler. + + YANG name: label-start + """ + + _yang_name: Final[str] = 'label-start' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelStartMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStart': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d3aeed125a790da60e394f9e834fb871ab9c3b9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStepMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-step + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-step + """ + + def __init__(self): + super().__init__(LabelStep) + + def __get__(self, instance, owner=None) -> ( + 'LabelStepMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStep': + pass + + def __enter__(self) -> 'LabelStep': + pass + + +class LabelStep( + YANGContainer, + metaclass=LabelStepMeta): + """ + YANG container handler. + + YANG name: label-step + """ + + _yang_name: Final[str] = 'label-step' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStep': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + LabelStepMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + LabelStepMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/from/label_restrictions/label_restriction/label_step/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c8d4f4c8def0e90dabe399cc305dc3b8d3d500 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: optimizations + """ + from .algorithm import Algorithm + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: optimizations + """ + + def __init__(self): + super().__init__(Optimizations) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Optimizations': + pass + + def __enter__(self) -> 'Optimizations': + pass + + +class Optimizations( + YANGContainer, + metaclass=OptimizationsMeta): + """ + YANG container handler. + + YANG name: optimizations + """ + + _yang_name: Final[str] = 'optimizations' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Optimizations': + instance = super().__new__(cls) + instance._yang_choices = { + + 'algorithm': + OptimizationsMeta.Algorithm( + instance), + } + return instance + + @property + def algorithm(self) -> ( + OptimizationsMeta.Algorithm): + return self._yang_choices['algorithm'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d82c7bf9c5ec990484589d660738ffe3d2d9f6bf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/__init__.py @@ -0,0 +1,101 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AlgorithmMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: algorithm + """ + + from .metric import Metric + from .objective_function import ObjectiveFunction + + class metric_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.Metric) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.metric_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + class objective_function_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.objective_function_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + +class Algorithm(YANGChoice, metaclass=AlgorithmMeta): + """ + YANG choice handler. + + YANG name: algorithm + """ + + _yang_name: Final[str] = 'algorithm' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'metric': ( + metric := ( # YANGChoiceCase( + AlgorithmMeta. + metric_case_descriptor())), + + 'objective-function': ( + objective_function := ( # YANGChoiceCase( + AlgorithmMeta. + objective_function_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e7d1da8ee3719d0d6a3c401df7340fbd3517e8ed --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: metric + """ + from .tiebreakers import Tiebreakers + from .optimization_metric import OptimizationMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__(Metric) + + def __get__(self, instance, owner=None) -> ( + 'MetricMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Metric': + pass + + def __enter__(self) -> 'Metric': + pass + + +class Metric( + YANGContainer, + metaclass=MetricMeta): + """ + YANG container handler. + + YANG name: metric + """ + + _yang_name: Final[str] = 'metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'tiebreakers': ( + tiebreakers := ( # YANGContainerMember( + MetricMeta. + Tiebreakers. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'optimization-metric': ( + optimization_metric := ( # YANGListMember( + MetricMeta. + OptimizationMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Metric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bad2331fc0f109b98bda93287a822244302b5d1e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/__init__.py @@ -0,0 +1,116 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: optimization-metric + """ + from .explicit_route_exclude_objects import ExplicitRouteExcludeObjects + from .explicit_route_include_objects import ExplicitRouteIncludeObjects + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: optimization-metric + """ + + def __init__(self): + super().__init__(OptimizationMetric) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['OptimizationMetric']: + pass + + def __iter__(self, key) -> Iterator['OptimizationMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'OptimizationMetric': + return super()[key] + + def __enter__(self) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + pass + + +class OptimizationMetric( + YANGListItem, + metaclass=OptimizationMetricMeta): + """ + YANG list item handler. + + YANG name: optimization-metric + """ + + _yang_name: Final[str] = 'optimization-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'weight': ( + weight := YANGLeafMember( + 'weight', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'explicit-route-exclude-objects': ( + explicit_route_exclude_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteExcludeObjects. + yang_container_descriptor())), + + 'explicit-route-include-objects': ( + explicit_route_include_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteIncludeObjects. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'OptimizationMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aea7bdd4cd5ed1743a1764899878a1ac8035348e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteExcludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + from .route_object_exclude_object import RouteObjectExcludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-exclude-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteExcludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteExcludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteExcludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteExcludeObjects': + pass + + +class ExplicitRouteExcludeObjects( + YANGContainer, + metaclass=ExplicitRouteExcludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + + _yang_name: Final[str] = 'explicit-route-exclude-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-exclude-object': ( + route_object_exclude_object := ( # YANGListMember( + ExplicitRouteExcludeObjectsMeta. + RouteObjectExcludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteExcludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..405906d3e6d9dd1eda79aae3a6302c37e0e24988 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectExcludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-exclude-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-exclude-object + """ + + def __init__(self): + super().__init__(RouteObjectExcludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectExcludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectExcludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectExcludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectExcludeObject( + YANGListItem, + metaclass=RouteObjectExcludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-exclude-object + """ + + _yang_name: Final[str] = 'route-object-exclude-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectExcludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectExcludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectExcludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8100bae93730074ddc472dfb8328dc9ec9b34a21 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py @@ -0,0 +1,217 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .label import Label + from .numbered_node_hop import NumberedNodeHop + from .numbered_link_hop import NumberedLinkHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + from .srlg import Srlg + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class srlg_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__( + TypeMeta.Srlg) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.srlg_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Srlg'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Srlg'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'srlg': ( + srlg := ( # YANGChoiceCase( + TypeMeta. + srlg_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8d9d3d58559fab79fa12a634fb4aecbef61780f1 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..420f996a13a20bf122ec87f0fbb109b34246eb61 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + from .srlg import Srlg + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'srlg': ( + srlg := ( # YANGContainerMember( + SrlgMeta. + Srlg. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..95a1628e4caf545e0d31823f89ea93178ffb76c7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'srlg': ( + srlg := YANGLeafMember( + 'srlg', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7de25b7bbfed705b63d9c681cad27d7bd9b9584d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3209b99bad73493077e9e91a8053f320b05c11c0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteIncludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-include-objects + """ + from .route_object_include_object import RouteObjectIncludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-include-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteIncludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteIncludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteIncludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteIncludeObjects': + pass + + +class ExplicitRouteIncludeObjects( + YANGContainer, + metaclass=ExplicitRouteIncludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-include-objects + """ + + _yang_name: Final[str] = 'explicit-route-include-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-include-object': ( + route_object_include_object := ( # YANGListMember( + ExplicitRouteIncludeObjectsMeta. + RouteObjectIncludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteIncludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c9f24330ff35e20e47be0db730f6ec682dd71d2d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectIncludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-include-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-include-object + """ + + def __init__(self): + super().__init__(RouteObjectIncludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectIncludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectIncludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectIncludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectIncludeObject( + YANGListItem, + metaclass=RouteObjectIncludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-include-object + """ + + _yang_name: Final[str] = 'route-object-include-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectIncludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectIncludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectIncludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5f251c42ed301ea688e4e921968867ed262acfa2 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_link_hop import NumberedLinkHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + from .label import Label + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..64a8ec6d5e2fd4a77c59c13b3e37cacb001c91fe --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7de25b7bbfed705b63d9c681cad27d7bd9b9584d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d345b57b342afaa50a04c5782794f34b810b795c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakersMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tiebreakers + """ + from .tiebreaker import Tiebreaker + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tiebreakers + """ + + def __init__(self): + super().__init__(Tiebreakers) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakersMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tiebreakers': + pass + + def __enter__(self) -> 'Tiebreakers': + pass + + +class Tiebreakers( + YANGContainer, + metaclass=TiebreakersMeta): + """ + YANG container handler. + + YANG name: tiebreakers + """ + + _yang_name: Final[str] = 'tiebreakers' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tiebreaker': ( + tiebreaker := ( # YANGListMember( + TiebreakersMeta. + Tiebreaker. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreakers': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..500d880ad6ad48b8079aa3bea0b1e644f7008f49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakerMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tiebreaker + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tiebreaker + """ + + def __init__(self): + super().__init__(Tiebreaker) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tiebreaker']: + pass + + def __iter__(self, key) -> Iterator['Tiebreaker']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tiebreaker': + return super()[key] + + def __enter__(self) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + pass + + +class Tiebreaker( + YANGListItem, + metaclass=TiebreakerMeta): + """ + YANG list item handler. + + YANG name: tiebreaker + """ + + _yang_name: Final[str] = 'tiebreaker' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tiebreaker-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tiebreaker-type': ( + tiebreaker_type := YANGLeafMember( + 'tiebreaker-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreaker': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbd32a2bb98c6e47f795103fbc122cbf7957e1e6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + from .objective_function import ObjectiveFunction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'objective-function': ( + objective_function := ( # YANGContainerMember( + ObjectiveFunctionMeta. + ObjectiveFunction. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..af72bcf2702ccee1d360bad39000241d1abfdc19 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/optimizations/algorithm/objective_function/objective_function/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'objective-function-type': ( + objective_function_type := YANGLeafMember( + 'objective-function-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6f5aceab23841faec8396e85e86e21692641125f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/__init__.py @@ -0,0 +1,151 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-constraints + """ + from .path_metric_bounds import PathMetricBounds + from .path_affinities_values import PathAffinitiesValues + from .path_srlgs_lists import PathSrlgsLists + from .path_srlgs_names import PathSrlgsNames + from .path_affinity_names import PathAffinityNames + from .te_bandwidth import TeBandwidth + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-constraints + """ + + def __init__(self): + super().__init__(PathConstraints) + + def __get__(self, instance, owner=None) -> ( + 'PathConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathConstraints': + pass + + def __enter__(self) -> 'PathConstraints': + pass + + +class PathConstraints( + YANGContainer, + metaclass=PathConstraintsMeta): + """ + YANG container handler. + + YANG name: path-constraints + """ + + _yang_name: Final[str] = 'path-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'disjointness': ( + disjointness := YANGLeafMember( + 'disjointness', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-protection': ( + link_protection := YANGLeafMember( + 'link-protection', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'signaling-type': ( + signaling_type := YANGLeafMember( + 'signaling-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hold-priority': ( + hold_priority := YANGLeafMember( + 'hold-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'setup-priority': ( + setup_priority := YANGLeafMember( + 'setup-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-metric-bounds': ( + path_metric_bounds := ( # YANGContainerMember( + PathConstraintsMeta. + PathMetricBounds. + yang_container_descriptor())), + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinitiesValues. + yang_container_descriptor())), + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsNames. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinityNames. + yang_container_descriptor())), + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + PathConstraintsMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7560d7f51b4174c036b96d1a6599a2a3ada8d674 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..356f7761b99b2e313b0638407dbaaa3996e6c418 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-metric-bounds + """ + from .path_metric_bound import PathMetricBound + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-metric-bounds + """ + + def __init__(self): + super().__init__(PathMetricBounds) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathMetricBounds': + pass + + def __enter__(self) -> 'PathMetricBounds': + pass + + +class PathMetricBounds( + YANGContainer, + metaclass=PathMetricBoundsMeta): + """ + YANG container handler. + + YANG name: path-metric-bounds + """ + + _yang_name: Final[str] = 'path-metric-bounds' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric-bound': ( + path_metric_bound := ( # YANGListMember( + PathMetricBoundsMeta. + PathMetricBound. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBounds': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2a97d5e3e1d7066756b051d139f997d9a46b3c6b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_metric_bounds/path_metric_bound/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric-bound + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric-bound + """ + + def __init__(self): + super().__init__(PathMetricBound) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetricBound']: + pass + + def __iter__(self, key) -> Iterator['PathMetricBound']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetricBound': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + pass + + +class PathMetricBound( + YANGListItem, + metaclass=PathMetricBoundMeta): + """ + YANG list item handler. + + YANG name: path-metric-bound + """ + + _yang_name: Final[str] = 'path-metric-bound' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'upper-bound': ( + upper_bound := YANGLeafMember( + 'upper-bound', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBound': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_constraints/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..df295258db86b4261becc2471833afaabe8421be --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/__init__.py @@ -0,0 +1,121 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathPropertiesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-properties + """ + from .path_affinities_values import PathAffinitiesValues + from .path_srlgs_names import PathSrlgsNames + from .path_route_objects import PathRouteObjects + from .path_srlgs_lists import PathSrlgsLists + from .path_affinity_names import PathAffinityNames + from .path_metric import PathMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-properties + """ + + def __init__(self): + super().__init__(PathProperties) + + def __get__(self, instance, owner=None) -> ( + 'PathPropertiesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathProperties': + pass + + def __enter__(self) -> 'PathProperties': + pass + + +class PathProperties( + YANGContainer, + metaclass=PathPropertiesMeta): + """ + YANG container handler. + + YANG name: path-properties + """ + + _yang_name: Final[str] = 'path-properties' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinitiesValues. + yang_container_descriptor())), + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsNames. + yang_container_descriptor())), + + 'path-route-objects': ( + path_route_objects := ( # YANGContainerMember( + PathPropertiesMeta. + PathRouteObjects. + yang_container_descriptor())), + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinityNames. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric': ( + path_metric := ( # YANGListMember( + PathPropertiesMeta. + PathMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathProperties': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d0e4a21b11accc2103aa85169cb46c386658d5cc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d6ae074074e7913854992f9bd32a8f51f6b9d7b7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_metric/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric + """ + + def __init__(self): + super().__init__(PathMetric) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetric']: + pass + + def __iter__(self, key) -> Iterator['PathMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetric': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricMeta.yang_list_descriptor'): + pass + + +class PathMetric( + YANGListItem, + metaclass=PathMetricMeta): + """ + YANG list item handler. + + YANG name: path-metric + """ + + _yang_name: Final[str] = 'path-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'accumulative-value': ( + accumulative_value := YANGLeafMember( + 'accumulative-value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2af8eb3f47d7b0ceb2d21f9f5b1ee44b432ab35f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-route-objects + """ + from .path_route_object import PathRouteObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-route-objects + """ + + def __init__(self): + super().__init__(PathRouteObjects) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathRouteObjects': + pass + + def __enter__(self) -> 'PathRouteObjects': + pass + + +class PathRouteObjects( + YANGContainer, + metaclass=PathRouteObjectsMeta): + """ + YANG container handler. + + YANG name: path-route-objects + """ + + _yang_name: Final[str] = 'path-route-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-route-object': ( + path_route_object := ( # YANGListMember( + PathRouteObjectsMeta. + PathRouteObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..74b9e21c769902d7a2bb1f362d2e95cbf5d862cd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-route-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-route-object + """ + + def __init__(self): + super().__init__(PathRouteObject) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathRouteObject']: + pass + + def __iter__(self, key) -> Iterator['PathRouteObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathRouteObject': + return super()[key] + + def __enter__(self) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + pass + + +class PathRouteObject( + YANGListItem, + metaclass=PathRouteObjectMeta): + """ + YANG list item handler. + + YANG name: path-route-object + """ + + _yang_name: Final[str] = 'path-route-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathRouteObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathRouteObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..28ea603a0e4ee2c731661a01ab1dbbee36529de5 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_link_hop import NumberedLinkHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .label import Label + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1cb78075b80ccd8887818376324a016daf17b67c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..652da89e61bd32067e97591a11a2970e965bed4a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/path_properties/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d03118f5c94e3726341c4332447847c61623d616 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ToMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: to + """ + from .label_restrictions import LabelRestrictions + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: to + """ + + def __init__(self): + super().__init__(To) + + def __get__(self, instance, owner=None) -> ( + 'ToMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'To': + pass + + def __enter__(self) -> 'To': + pass + + +class To( + YANGContainer, + metaclass=ToMeta): + """ + YANG container handler. + + YANG name: to + """ + + _yang_name: Final[str] = 'to' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tp-ref': ( + tp_ref := YANGLeafMember( + 'tp-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-restrictions': ( + label_restrictions := ( # YANGContainerMember( + ToMeta. + LabelRestrictions. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'To': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29f30ca794c567238bb34de6d5de219f72b68cca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-restrictions + """ + from .label_restriction import LabelRestriction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-restrictions + """ + + def __init__(self): + super().__init__(LabelRestrictions) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelRestrictions': + pass + + def __enter__(self) -> 'LabelRestrictions': + pass + + +class LabelRestrictions( + YANGContainer, + metaclass=LabelRestrictionsMeta): + """ + YANG container handler. + + YANG name: label-restrictions + """ + + _yang_name: Final[str] = 'label-restrictions' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'label-restriction': ( + label_restriction := ( # YANGListMember( + LabelRestrictionsMeta. + LabelRestriction. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestrictions': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d6963852ba0c84a4b78122f6ad1185f29748eb5f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: label-restriction + """ + from .label_start import LabelStart + from .label_step import LabelStep + from .label_end import LabelEnd + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: label-restriction + """ + + def __init__(self): + super().__init__(LabelRestriction) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LabelRestriction']: + pass + + def __iter__(self, key) -> Iterator['LabelRestriction']: + return super().__iter__() + + def __getitem__(self, key) -> 'LabelRestriction': + return super()[key] + + def __enter__(self) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + pass + + +class LabelRestriction( + YANGListItem, + metaclass=LabelRestrictionMeta): + """ + YANG list item handler. + + YANG name: label-restriction + """ + + _yang_name: Final[str] = 'label-restriction' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'range-bitmap': ( + range_bitmap := YANGLeafMember( + 'range-bitmap', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restriction': ( + restriction := YANGLeafMember( + 'restriction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-start': ( + label_start := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStart. + yang_container_descriptor())), + + 'label-step': ( + label_step := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStep. + yang_container_descriptor())), + + 'label-end': ( + label_end := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelEnd. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestriction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ad525773e032b7b224f5b661e728ffe8950e98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelEndMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-end + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-end + """ + + def __init__(self): + super().__init__(LabelEnd) + + def __get__(self, instance, owner=None) -> ( + 'LabelEndMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelEnd': + pass + + def __enter__(self) -> 'LabelEnd': + pass + + +class LabelEnd( + YANGContainer, + metaclass=LabelEndMeta): + """ + YANG container handler. + + YANG name: label-end + """ + + _yang_name: Final[str] = 'label-end' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelEndMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelEnd': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8985523ba0c69fac8fbd1852bd47f2891d92bc6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStartMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-start + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-start + """ + + def __init__(self): + super().__init__(LabelStart) + + def __get__(self, instance, owner=None) -> ( + 'LabelStartMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStart': + pass + + def __enter__(self) -> 'LabelStart': + pass + + +class LabelStart( + YANGContainer, + metaclass=LabelStartMeta): + """ + YANG container handler. + + YANG name: label-start + """ + + _yang_name: Final[str] = 'label-start' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelStartMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStart': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d3aeed125a790da60e394f9e834fb871ab9c3b9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStepMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-step + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-step + """ + + def __init__(self): + super().__init__(LabelStep) + + def __get__(self, instance, owner=None) -> ( + 'LabelStepMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStep': + pass + + def __enter__(self) -> 'LabelStep': + pass + + +class LabelStep( + YANGContainer, + metaclass=LabelStepMeta): + """ + YANG container handler. + + YANG name: label-step + """ + + _yang_name: Final[str] = 'label-step' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStep': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + LabelStepMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + LabelStepMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/to/label_restrictions/label_restriction/label_step/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ac722c47add5d381fef94d2c3a2f5750b49a2688 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/__init__.py @@ -0,0 +1,119 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay + """ + from .tunnels import Tunnels + from .tunnel_termination_points import TunnelTerminationPoints + from .primary_path import PrimaryPath + from .backup_path import BackupPath + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay + """ + + def __init__(self): + super().__init__(Underlay) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Underlay': + pass + + def __enter__(self) -> 'Underlay': + pass + + +class Underlay( + YANGContainer, + metaclass=UnderlayMeta): + """ + YANG container handler. + + YANG name: underlay + """ + + _yang_name: Final[str] = 'underlay' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'enabled': ( + enabled := YANGLeafMember( + 'enabled', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'protection-type': ( + protection_type := YANGLeafMember( + 'protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'tunnels': ( + tunnels := ( # YANGContainerMember( + UnderlayMeta. + Tunnels. + yang_container_descriptor())), + + 'tunnel-termination-points': ( + tunnel_termination_points := ( # YANGContainerMember( + UnderlayMeta. + TunnelTerminationPoints. + yang_container_descriptor())), + + 'primary-path': ( + primary_path := ( # YANGContainerMember( + UnderlayMeta. + PrimaryPath. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'backup-path': ( + backup_path := ( # YANGListMember( + UnderlayMeta. + BackupPath. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Underlay': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6b6e1ff5cb9da5f8c265df0f8c0854de089ff9ef --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/__init__.py @@ -0,0 +1,109 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BackupPathMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: backup-path + """ + from .path_element import PathElement + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: backup-path + """ + + def __init__(self): + super().__init__(BackupPath) + + def __get__(self, instance, owner=None) -> ( + 'BackupPathMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['BackupPath']: + pass + + def __iter__(self, key) -> Iterator['BackupPath']: + return super().__iter__() + + def __getitem__(self, key) -> 'BackupPath': + return super()[key] + + def __enter__(self) -> ( + 'BackupPathMeta.yang_list_descriptor'): + pass + + +class BackupPath( + YANGListItem, + metaclass=BackupPathMeta): + """ + YANG list item handler. + + YANG name: backup-path + """ + + _yang_name: Final[str] = 'backup-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + BackupPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'BackupPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..39f656215584aa2bcf14b3ba1a003b8347ff4977 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .unnumbered_link_hop import UnnumberedLinkHop + from .numbered_link_hop import NumberedLinkHop + from .as_number import AsNumber + from .label import Label + from .numbered_node_hop import NumberedNodeHop + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1cb78075b80ccd8887818376324a016daf17b67c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..17a8ab32f6e4e90649c07d42b9433c6639fb2934 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..34a2a729ce6d45e11174065699c428a7ac677a8b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PrimaryPathMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: primary-path + """ + from .path_element import PathElement + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: primary-path + """ + + def __init__(self): + super().__init__(PrimaryPath) + + def __get__(self, instance, owner=None) -> ( + 'PrimaryPathMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PrimaryPath': + pass + + def __enter__(self) -> 'PrimaryPath': + pass + + +class PrimaryPath( + YANGContainer, + metaclass=PrimaryPathMeta): + """ + YANG container handler. + + YANG name: primary-path + """ + + _yang_name: Final[str] = 'primary-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + PrimaryPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PrimaryPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e01f01986b3d51fd6143967c4f05b169aff11129 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + from .numbered_link_hop import NumberedLinkHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .label import Label + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c993df52db1f2e1aa1085a57856c8585fcba58 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..652da89e61bd32067e97591a11a2970e965bed4a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8ae8cc268f3c4fc331cd1e1018be41d113da9183 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnel_termination_points/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelTerminationPointsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnel-termination-points + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnel-termination-points + """ + + def __init__(self): + super().__init__(TunnelTerminationPoints) + + def __get__(self, instance, owner=None) -> ( + 'TunnelTerminationPointsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TunnelTerminationPoints': + pass + + def __enter__(self) -> 'TunnelTerminationPoints': + pass + + +class TunnelTerminationPoints( + YANGContainer, + metaclass=TunnelTerminationPointsMeta): + """ + YANG container handler. + + YANG name: tunnel-termination-points + """ + + _yang_name: Final[str] = 'tunnel-termination-points' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'source': ( + source := YANGLeafMember( + 'source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'destination': ( + destination := YANGLeafMember( + 'destination', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TunnelTerminationPoints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..303858f3e0c28faecf9696d2fbf403d5510cced8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnels + """ + from .tunnel import Tunnel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnels + """ + + def __init__(self): + super().__init__(Tunnels) + + def __get__(self, instance, owner=None) -> ( + 'TunnelsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tunnels': + pass + + def __enter__(self) -> 'Tunnels': + pass + + +class Tunnels( + YANGContainer, + metaclass=TunnelsMeta): + """ + YANG container handler. + + YANG name: tunnels + """ + + _yang_name: Final[str] = 'tunnels' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tunnel': ( + tunnel := ( # YANGListMember( + TunnelsMeta. + Tunnel. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnels': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f854dfd329ce016317b7b9743ace874769f03094 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/connectivity_matrix/underlay/tunnels/tunnel/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tunnel + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tunnel + """ + + def __init__(self): + super().__init__(Tunnel) + + def __get__(self, instance, owner=None) -> ( + 'TunnelMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tunnel']: + pass + + def __iter__(self, key) -> Iterator['Tunnel']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tunnel': + return super()[key] + + def __enter__(self) -> ( + 'TunnelMeta.yang_list_descriptor'): + pass + + +class Tunnel( + YANGListItem, + metaclass=TunnelMeta): + """ + YANG list item handler. + + YANG name: tunnel + """ + + _yang_name: Final[str] = 'tunnel' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tunnel-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'tunnel-name': ( + tunnel_name := YANGLeafMember( + 'tunnel-name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnel': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29f30ca794c567238bb34de6d5de219f72b68cca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-restrictions + """ + from .label_restriction import LabelRestriction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-restrictions + """ + + def __init__(self): + super().__init__(LabelRestrictions) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelRestrictions': + pass + + def __enter__(self) -> 'LabelRestrictions': + pass + + +class LabelRestrictions( + YANGContainer, + metaclass=LabelRestrictionsMeta): + """ + YANG container handler. + + YANG name: label-restrictions + """ + + _yang_name: Final[str] = 'label-restrictions' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'label-restriction': ( + label_restriction := ( # YANGListMember( + LabelRestrictionsMeta. + LabelRestriction. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestrictions': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..832dd2f7ef2d442bd2e0efe6ad680c3d4fd15402 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: label-restriction + """ + from .label_end import LabelEnd + from .label_start import LabelStart + from .label_step import LabelStep + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: label-restriction + """ + + def __init__(self): + super().__init__(LabelRestriction) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LabelRestriction']: + pass + + def __iter__(self, key) -> Iterator['LabelRestriction']: + return super().__iter__() + + def __getitem__(self, key) -> 'LabelRestriction': + return super()[key] + + def __enter__(self) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + pass + + +class LabelRestriction( + YANGListItem, + metaclass=LabelRestrictionMeta): + """ + YANG list item handler. + + YANG name: label-restriction + """ + + _yang_name: Final[str] = 'label-restriction' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'restriction': ( + restriction := YANGLeafMember( + 'restriction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'range-bitmap': ( + range_bitmap := YANGLeafMember( + 'range-bitmap', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-end': ( + label_end := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelEnd. + yang_container_descriptor())), + + 'label-start': ( + label_start := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStart. + yang_container_descriptor())), + + 'label-step': ( + label_step := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStep. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestriction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ad525773e032b7b224f5b661e728ffe8950e98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelEndMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-end + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-end + """ + + def __init__(self): + super().__init__(LabelEnd) + + def __get__(self, instance, owner=None) -> ( + 'LabelEndMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelEnd': + pass + + def __enter__(self) -> 'LabelEnd': + pass + + +class LabelEnd( + YANGContainer, + metaclass=LabelEndMeta): + """ + YANG container handler. + + YANG name: label-end + """ + + _yang_name: Final[str] = 'label-end' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelEndMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelEnd': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8985523ba0c69fac8fbd1852bd47f2891d92bc6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStartMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-start + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-start + """ + + def __init__(self): + super().__init__(LabelStart) + + def __get__(self, instance, owner=None) -> ( + 'LabelStartMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStart': + pass + + def __enter__(self) -> 'LabelStart': + pass + + +class LabelStart( + YANGContainer, + metaclass=LabelStartMeta): + """ + YANG container handler. + + YANG name: label-start + """ + + _yang_name: Final[str] = 'label-start' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelStartMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStart': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d3aeed125a790da60e394f9e834fb871ab9c3b9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStepMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-step + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-step + """ + + def __init__(self): + super().__init__(LabelStep) + + def __get__(self, instance, owner=None) -> ( + 'LabelStepMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStep': + pass + + def __enter__(self) -> 'LabelStep': + pass + + +class LabelStep( + YANGContainer, + metaclass=LabelStepMeta): + """ + YANG container handler. + + YANG name: label-step + """ + + _yang_name: Final[str] = 'label-step' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStep': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + LabelStepMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + LabelStepMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/label_restrictions/label_restriction/label_step/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c8d4f4c8def0e90dabe399cc305dc3b8d3d500 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: optimizations + """ + from .algorithm import Algorithm + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: optimizations + """ + + def __init__(self): + super().__init__(Optimizations) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Optimizations': + pass + + def __enter__(self) -> 'Optimizations': + pass + + +class Optimizations( + YANGContainer, + metaclass=OptimizationsMeta): + """ + YANG container handler. + + YANG name: optimizations + """ + + _yang_name: Final[str] = 'optimizations' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Optimizations': + instance = super().__new__(cls) + instance._yang_choices = { + + 'algorithm': + OptimizationsMeta.Algorithm( + instance), + } + return instance + + @property + def algorithm(self) -> ( + OptimizationsMeta.Algorithm): + return self._yang_choices['algorithm'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d82c7bf9c5ec990484589d660738ffe3d2d9f6bf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/__init__.py @@ -0,0 +1,101 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AlgorithmMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: algorithm + """ + + from .metric import Metric + from .objective_function import ObjectiveFunction + + class metric_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.Metric) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.metric_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + class objective_function_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.objective_function_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + +class Algorithm(YANGChoice, metaclass=AlgorithmMeta): + """ + YANG choice handler. + + YANG name: algorithm + """ + + _yang_name: Final[str] = 'algorithm' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'metric': ( + metric := ( # YANGChoiceCase( + AlgorithmMeta. + metric_case_descriptor())), + + 'objective-function': ( + objective_function := ( # YANGChoiceCase( + AlgorithmMeta. + objective_function_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e7d1da8ee3719d0d6a3c401df7340fbd3517e8ed --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: metric + """ + from .tiebreakers import Tiebreakers + from .optimization_metric import OptimizationMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__(Metric) + + def __get__(self, instance, owner=None) -> ( + 'MetricMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Metric': + pass + + def __enter__(self) -> 'Metric': + pass + + +class Metric( + YANGContainer, + metaclass=MetricMeta): + """ + YANG container handler. + + YANG name: metric + """ + + _yang_name: Final[str] = 'metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'tiebreakers': ( + tiebreakers := ( # YANGContainerMember( + MetricMeta. + Tiebreakers. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'optimization-metric': ( + optimization_metric := ( # YANGListMember( + MetricMeta. + OptimizationMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Metric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e5e69ea24d5d4bc36b6bf78a13fb98a25a1e5916 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/__init__.py @@ -0,0 +1,116 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: optimization-metric + """ + from .explicit_route_exclude_objects import ExplicitRouteExcludeObjects + from .explicit_route_include_objects import ExplicitRouteIncludeObjects + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: optimization-metric + """ + + def __init__(self): + super().__init__(OptimizationMetric) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['OptimizationMetric']: + pass + + def __iter__(self, key) -> Iterator['OptimizationMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'OptimizationMetric': + return super()[key] + + def __enter__(self) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + pass + + +class OptimizationMetric( + YANGListItem, + metaclass=OptimizationMetricMeta): + """ + YANG list item handler. + + YANG name: optimization-metric + """ + + _yang_name: Final[str] = 'optimization-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'weight': ( + weight := YANGLeafMember( + 'weight', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'explicit-route-exclude-objects': ( + explicit_route_exclude_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteExcludeObjects. + yang_container_descriptor())), + + 'explicit-route-include-objects': ( + explicit_route_include_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteIncludeObjects. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'OptimizationMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aea7bdd4cd5ed1743a1764899878a1ac8035348e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteExcludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + from .route_object_exclude_object import RouteObjectExcludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-exclude-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteExcludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteExcludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteExcludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteExcludeObjects': + pass + + +class ExplicitRouteExcludeObjects( + YANGContainer, + metaclass=ExplicitRouteExcludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + + _yang_name: Final[str] = 'explicit-route-exclude-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-exclude-object': ( + route_object_exclude_object := ( # YANGListMember( + ExplicitRouteExcludeObjectsMeta. + RouteObjectExcludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteExcludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..405906d3e6d9dd1eda79aae3a6302c37e0e24988 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectExcludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-exclude-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-exclude-object + """ + + def __init__(self): + super().__init__(RouteObjectExcludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectExcludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectExcludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectExcludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectExcludeObject( + YANGListItem, + metaclass=RouteObjectExcludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-exclude-object + """ + + _yang_name: Final[str] = 'route-object-exclude-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectExcludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectExcludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectExcludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..519535f45f22cf80d11d26ecfff5511b21632ae4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py @@ -0,0 +1,217 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_link_hop import NumberedLinkHop + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + from .srlg import Srlg + from .label import Label + from .unnumbered_link_hop import UnnumberedLinkHop + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class srlg_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__( + TypeMeta.Srlg) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.srlg_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Srlg'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Srlg'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'srlg': ( + srlg := ( # YANGChoiceCase( + TypeMeta. + srlg_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c993df52db1f2e1aa1085a57856c8585fcba58 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..420f996a13a20bf122ec87f0fbb109b34246eb61 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + from .srlg import Srlg + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'srlg': ( + srlg := ( # YANGContainerMember( + SrlgMeta. + Srlg. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..95a1628e4caf545e0d31823f89ea93178ffb76c7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'srlg': ( + srlg := YANGLeafMember( + 'srlg', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cdc24c09f1b3ccadebb91f2dbb9442bbfbd3595d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3209b99bad73493077e9e91a8053f320b05c11c0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteIncludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-include-objects + """ + from .route_object_include_object import RouteObjectIncludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-include-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteIncludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteIncludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteIncludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteIncludeObjects': + pass + + +class ExplicitRouteIncludeObjects( + YANGContainer, + metaclass=ExplicitRouteIncludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-include-objects + """ + + _yang_name: Final[str] = 'explicit-route-include-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-include-object': ( + route_object_include_object := ( # YANGListMember( + ExplicitRouteIncludeObjectsMeta. + RouteObjectIncludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteIncludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c9f24330ff35e20e47be0db730f6ec682dd71d2d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectIncludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-include-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-include-object + """ + + def __init__(self): + super().__init__(RouteObjectIncludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectIncludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectIncludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectIncludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectIncludeObject( + YANGListItem, + metaclass=RouteObjectIncludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-include-object + """ + + _yang_name: Final[str] = 'route-object-include-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectIncludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectIncludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectIncludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0fc658253392d53b5678ebb702dd6ecb3cee4165 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_link_hop import NumberedLinkHop + from .numbered_node_hop import NumberedNodeHop + from .as_number import AsNumber + from .label import Label + from .unnumbered_link_hop import UnnumberedLinkHop + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c993df52db1f2e1aa1085a57856c8585fcba58 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5baa996de0fff24876e40ec73f87a7a90da1f2ea --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d345b57b342afaa50a04c5782794f34b810b795c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakersMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tiebreakers + """ + from .tiebreaker import Tiebreaker + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tiebreakers + """ + + def __init__(self): + super().__init__(Tiebreakers) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakersMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tiebreakers': + pass + + def __enter__(self) -> 'Tiebreakers': + pass + + +class Tiebreakers( + YANGContainer, + metaclass=TiebreakersMeta): + """ + YANG container handler. + + YANG name: tiebreakers + """ + + _yang_name: Final[str] = 'tiebreakers' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tiebreaker': ( + tiebreaker := ( # YANGListMember( + TiebreakersMeta. + Tiebreaker. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreakers': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..500d880ad6ad48b8079aa3bea0b1e644f7008f49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakerMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tiebreaker + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tiebreaker + """ + + def __init__(self): + super().__init__(Tiebreaker) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tiebreaker']: + pass + + def __iter__(self, key) -> Iterator['Tiebreaker']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tiebreaker': + return super()[key] + + def __enter__(self) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + pass + + +class Tiebreaker( + YANGListItem, + metaclass=TiebreakerMeta): + """ + YANG list item handler. + + YANG name: tiebreaker + """ + + _yang_name: Final[str] = 'tiebreaker' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tiebreaker-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tiebreaker-type': ( + tiebreaker_type := YANGLeafMember( + 'tiebreaker-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreaker': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbd32a2bb98c6e47f795103fbc122cbf7957e1e6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/objective_function/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + from .objective_function import ObjectiveFunction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'objective-function': ( + objective_function := ( # YANGContainerMember( + ObjectiveFunctionMeta. + ObjectiveFunction. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/objective_function/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/objective_function/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..af72bcf2702ccee1d360bad39000241d1abfdc19 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/optimizations/algorithm/objective_function/objective_function/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'objective-function-type': ( + objective_function_type := YANGLeafMember( + 'objective-function-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..28191362a8a0f4d9e8af895e993672214dc2b00f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/__init__.py @@ -0,0 +1,151 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-constraints + """ + from .path_metric_bounds import PathMetricBounds + from .path_affinity_names import PathAffinityNames + from .path_srlgs_lists import PathSrlgsLists + from .path_srlgs_names import PathSrlgsNames + from .te_bandwidth import TeBandwidth + from .path_affinities_values import PathAffinitiesValues + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-constraints + """ + + def __init__(self): + super().__init__(PathConstraints) + + def __get__(self, instance, owner=None) -> ( + 'PathConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathConstraints': + pass + + def __enter__(self) -> 'PathConstraints': + pass + + +class PathConstraints( + YANGContainer, + metaclass=PathConstraintsMeta): + """ + YANG container handler. + + YANG name: path-constraints + """ + + _yang_name: Final[str] = 'path-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'setup-priority': ( + setup_priority := YANGLeafMember( + 'setup-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'disjointness': ( + disjointness := YANGLeafMember( + 'disjointness', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'signaling-type': ( + signaling_type := YANGLeafMember( + 'signaling-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hold-priority': ( + hold_priority := YANGLeafMember( + 'hold-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-protection': ( + link_protection := YANGLeafMember( + 'link-protection', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-metric-bounds': ( + path_metric_bounds := ( # YANGContainerMember( + PathConstraintsMeta. + PathMetricBounds. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinityNames. + yang_container_descriptor())), + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsNames. + yang_container_descriptor())), + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + PathConstraintsMeta. + TeBandwidth. + yang_container_descriptor())), + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinitiesValues. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7560d7f51b4174c036b96d1a6599a2a3ada8d674 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..356f7761b99b2e313b0638407dbaaa3996e6c418 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-metric-bounds + """ + from .path_metric_bound import PathMetricBound + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-metric-bounds + """ + + def __init__(self): + super().__init__(PathMetricBounds) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathMetricBounds': + pass + + def __enter__(self) -> 'PathMetricBounds': + pass + + +class PathMetricBounds( + YANGContainer, + metaclass=PathMetricBoundsMeta): + """ + YANG container handler. + + YANG name: path-metric-bounds + """ + + _yang_name: Final[str] = 'path-metric-bounds' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric-bound': ( + path_metric_bound := ( # YANGListMember( + PathMetricBoundsMeta. + PathMetricBound. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBounds': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2a97d5e3e1d7066756b051d139f997d9a46b3c6b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_metric_bounds/path_metric_bound/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric-bound + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric-bound + """ + + def __init__(self): + super().__init__(PathMetricBound) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetricBound']: + pass + + def __iter__(self, key) -> Iterator['PathMetricBound']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetricBound': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + pass + + +class PathMetricBound( + YANGListItem, + metaclass=PathMetricBoundMeta): + """ + YANG list item handler. + + YANG name: path-metric-bound + """ + + _yang_name: Final[str] = 'path-metric-bound' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'upper-bound': ( + upper_bound := YANGLeafMember( + 'upper-bound', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBound': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_constraints/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..149786798cff216d2d5c3159b457969263950a72 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/__init__.py @@ -0,0 +1,121 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathPropertiesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-properties + """ + from .path_affinities_values import PathAffinitiesValues + from .path_route_objects import PathRouteObjects + from .path_srlgs_lists import PathSrlgsLists + from .path_affinity_names import PathAffinityNames + from .path_srlgs_names import PathSrlgsNames + from .path_metric import PathMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-properties + """ + + def __init__(self): + super().__init__(PathProperties) + + def __get__(self, instance, owner=None) -> ( + 'PathPropertiesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathProperties': + pass + + def __enter__(self) -> 'PathProperties': + pass + + +class PathProperties( + YANGContainer, + metaclass=PathPropertiesMeta): + """ + YANG container handler. + + YANG name: path-properties + """ + + _yang_name: Final[str] = 'path-properties' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinitiesValues. + yang_container_descriptor())), + + 'path-route-objects': ( + path_route_objects := ( # YANGContainerMember( + PathPropertiesMeta. + PathRouteObjects. + yang_container_descriptor())), + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinityNames. + yang_container_descriptor())), + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsNames. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric': ( + path_metric := ( # YANGListMember( + PathPropertiesMeta. + PathMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathProperties': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d0e4a21b11accc2103aa85169cb46c386658d5cc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7645abedd4d25aeb9c77aa579c2972a450d00a6e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_metric/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric + """ + + def __init__(self): + super().__init__(PathMetric) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetric']: + pass + + def __iter__(self, key) -> Iterator['PathMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetric': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricMeta.yang_list_descriptor'): + pass + + +class PathMetric( + YANGListItem, + metaclass=PathMetricMeta): + """ + YANG list item handler. + + YANG name: path-metric + """ + + _yang_name: Final[str] = 'path-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'accumulative-value': ( + accumulative_value := YANGLeafMember( + 'accumulative-value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2af8eb3f47d7b0ceb2d21f9f5b1ee44b432ab35f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-route-objects + """ + from .path_route_object import PathRouteObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-route-objects + """ + + def __init__(self): + super().__init__(PathRouteObjects) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathRouteObjects': + pass + + def __enter__(self) -> 'PathRouteObjects': + pass + + +class PathRouteObjects( + YANGContainer, + metaclass=PathRouteObjectsMeta): + """ + YANG container handler. + + YANG name: path-route-objects + """ + + _yang_name: Final[str] = 'path-route-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-route-object': ( + path_route_object := ( # YANGListMember( + PathRouteObjectsMeta. + PathRouteObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..74b9e21c769902d7a2bb1f362d2e95cbf5d862cd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-route-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-route-object + """ + + def __init__(self): + super().__init__(PathRouteObject) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathRouteObject']: + pass + + def __iter__(self, key) -> Iterator['PathRouteObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathRouteObject': + return super()[key] + + def __enter__(self) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + pass + + +class PathRouteObject( + YANGListItem, + metaclass=PathRouteObjectMeta): + """ + YANG list item handler. + + YANG name: path-route-object + """ + + _yang_name: Final[str] = 'path-route-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathRouteObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathRouteObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5f251c42ed301ea688e4e921968867ed262acfa2 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_link_hop import NumberedLinkHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + from .label import Label + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1abedb4d3f8145943387f3e66e3e17fed741dcdc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..07c0b7b779289a6ac9a9123fd540526dc6d190fb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/path_properties/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9ef388cd63aa7c8947fc3391bad703bb01f3d827 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/__init__.py @@ -0,0 +1,119 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay + """ + from .primary_path import PrimaryPath + from .tunnel_termination_points import TunnelTerminationPoints + from .tunnels import Tunnels + from .backup_path import BackupPath + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay + """ + + def __init__(self): + super().__init__(Underlay) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Underlay': + pass + + def __enter__(self) -> 'Underlay': + pass + + +class Underlay( + YANGContainer, + metaclass=UnderlayMeta): + """ + YANG container handler. + + YANG name: underlay + """ + + _yang_name: Final[str] = 'underlay' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'enabled': ( + enabled := YANGLeafMember( + 'enabled', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'protection-type': ( + protection_type := YANGLeafMember( + 'protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'primary-path': ( + primary_path := ( # YANGContainerMember( + UnderlayMeta. + PrimaryPath. + yang_container_descriptor())), + + 'tunnel-termination-points': ( + tunnel_termination_points := ( # YANGContainerMember( + UnderlayMeta. + TunnelTerminationPoints. + yang_container_descriptor())), + + 'tunnels': ( + tunnels := ( # YANGContainerMember( + UnderlayMeta. + Tunnels. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'backup-path': ( + backup_path := ( # YANGListMember( + UnderlayMeta. + BackupPath. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Underlay': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6b6e1ff5cb9da5f8c265df0f8c0854de089ff9ef --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/__init__.py @@ -0,0 +1,109 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BackupPathMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: backup-path + """ + from .path_element import PathElement + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: backup-path + """ + + def __init__(self): + super().__init__(BackupPath) + + def __get__(self, instance, owner=None) -> ( + 'BackupPathMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['BackupPath']: + pass + + def __iter__(self, key) -> Iterator['BackupPath']: + return super().__iter__() + + def __getitem__(self, key) -> 'BackupPath': + return super()[key] + + def __enter__(self) -> ( + 'BackupPathMeta.yang_list_descriptor'): + pass + + +class BackupPath( + YANGListItem, + metaclass=BackupPathMeta): + """ + YANG list item handler. + + YANG name: backup-path + """ + + _yang_name: Final[str] = 'backup-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + BackupPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'BackupPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e16cb666ce1a7bc800b744b15e11b1d4b7279e6d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .as_number import AsNumber + from .label import Label + from .numbered_node_hop import NumberedNodeHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .numbered_link_hop import NumberedLinkHop + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1abedb4d3f8145943387f3e66e3e17fed741dcdc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6c1142926ba50c34d71606b198e801811b621385 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..34a2a729ce6d45e11174065699c428a7ac677a8b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PrimaryPathMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: primary-path + """ + from .path_element import PathElement + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: primary-path + """ + + def __init__(self): + super().__init__(PrimaryPath) + + def __get__(self, instance, owner=None) -> ( + 'PrimaryPathMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PrimaryPath': + pass + + def __enter__(self) -> 'PrimaryPath': + pass + + +class PrimaryPath( + YANGContainer, + metaclass=PrimaryPathMeta): + """ + YANG container handler. + + YANG name: primary-path + """ + + _yang_name: Final[str] = 'primary-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + PrimaryPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PrimaryPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c00e57c237e53df3a2bba30cffe83a15d1149756 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .label import Label + from .numbered_node_hop import NumberedNodeHop + from .numbered_link_hop import NumberedLinkHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1cb78075b80ccd8887818376324a016daf17b67c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8ee74a2b7c7f647d2a88dfb22f44ed0ec1e80e4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8ae8cc268f3c4fc331cd1e1018be41d113da9183 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnel_termination_points/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelTerminationPointsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnel-termination-points + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnel-termination-points + """ + + def __init__(self): + super().__init__(TunnelTerminationPoints) + + def __get__(self, instance, owner=None) -> ( + 'TunnelTerminationPointsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TunnelTerminationPoints': + pass + + def __enter__(self) -> 'TunnelTerminationPoints': + pass + + +class TunnelTerminationPoints( + YANGContainer, + metaclass=TunnelTerminationPointsMeta): + """ + YANG container handler. + + YANG name: tunnel-termination-points + """ + + _yang_name: Final[str] = 'tunnel-termination-points' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'source': ( + source := YANGLeafMember( + 'source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'destination': ( + destination := YANGLeafMember( + 'destination', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TunnelTerminationPoints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..303858f3e0c28faecf9696d2fbf403d5510cced8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnels + """ + from .tunnel import Tunnel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnels + """ + + def __init__(self): + super().__init__(Tunnels) + + def __get__(self, instance, owner=None) -> ( + 'TunnelsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tunnels': + pass + + def __enter__(self) -> 'Tunnels': + pass + + +class Tunnels( + YANGContainer, + metaclass=TunnelsMeta): + """ + YANG container handler. + + YANG name: tunnels + """ + + _yang_name: Final[str] = 'tunnels' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tunnel': ( + tunnel := ( # YANGListMember( + TunnelsMeta. + Tunnel. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnels': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d36aa35acd17db473e177b143afdec573f0b4927 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/connectivity_matrices/underlay/tunnels/tunnel/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tunnel + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tunnel + """ + + def __init__(self): + super().__init__(Tunnel) + + def __get__(self, instance, owner=None) -> ( + 'TunnelMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tunnel']: + pass + + def __iter__(self, key) -> Iterator['Tunnel']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tunnel': + return super()[key] + + def __enter__(self) -> ( + 'TunnelMeta.yang_list_descriptor'): + pass + + +class Tunnel( + YANGListItem, + metaclass=TunnelMeta): + """ + YANG list item handler. + + YANG name: tunnel + """ + + _yang_name: Final[str] = 'tunnel' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tunnel-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tunnel-name': ( + tunnel_name := YANGLeafMember( + 'tunnel-name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnel': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/underlay_topology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/underlay_topology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..42dee7a72fe4a5d79128cf6ad278af68094e6692 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/te_node_attributes/underlay_topology/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayTopologyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay-topology + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay-topology + """ + + def __init__(self): + super().__init__(UnderlayTopology) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayTopologyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnderlayTopology': + pass + + def __enter__(self) -> 'UnderlayTopology': + pass + + +class UnderlayTopology( + YANGContainer, + metaclass=UnderlayTopologyMeta): + """ + YANG container handler. + + YANG name: underlay-topology + """ + + _yang_name: Final[str] = 'underlay-topology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnderlayTopology': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3a2840f2560d9dcbb55f2d1dcd7515046766223b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/__init__.py @@ -0,0 +1,167 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelTerminationPointMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tunnel-termination-point + """ + from .client_layer_adaptation import ClientLayerAdaptation + from .statistics import Statistics + from .local_link_connectivities import LocalLinkConnectivities + from .geolocation import Geolocation + from .supporting_tunnel_termination_point import SupportingTunnelTerminationPoint + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tunnel-termination-point + """ + + def __init__(self): + super().__init__(TunnelTerminationPoint) + + def __get__(self, instance, owner=None) -> ( + 'TunnelTerminationPointMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['TunnelTerminationPoint']: + pass + + def __iter__(self, key) -> Iterator['TunnelTerminationPoint']: + return super().__iter__() + + def __getitem__(self, key) -> 'TunnelTerminationPoint': + return super()[key] + + def __enter__(self) -> ( + 'TunnelTerminationPointMeta.yang_list_descriptor'): + pass + + +class TunnelTerminationPoint( + YANGListItem, + metaclass=TunnelTerminationPointMeta): + """ + YANG list item handler. + + YANG name: tunnel-termination-point + """ + + _yang_name: Final[str] = 'tunnel-termination-point' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tunnel-tp-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'protection-type': ( + protection_type := YANGLeafMember( + 'protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'admin-status': ( + admin_status := YANGLeafMember( + 'admin-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'tunnel-tp-id': ( + tunnel_tp_id := YANGLeafMember( + 'tunnel-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'encoding': ( + encoding := YANGLeafMember( + 'encoding', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'switching-capability': ( + switching_capability := YANGLeafMember( + 'switching-capability', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'oper-status': ( + oper_status := YANGLeafMember( + 'oper-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'client-layer-adaptation': ( + client_layer_adaptation := ( # YANGContainerMember( + TunnelTerminationPointMeta. + ClientLayerAdaptation. + yang_container_descriptor())), + + 'statistics': ( + statistics := ( # YANGContainerMember( + TunnelTerminationPointMeta. + Statistics. + yang_container_descriptor())), + + 'local-link-connectivities': ( + local_link_connectivities := ( # YANGContainerMember( + TunnelTerminationPointMeta. + LocalLinkConnectivities. + yang_container_descriptor())), + + 'geolocation': ( + geolocation := ( # YANGContainerMember( + TunnelTerminationPointMeta. + Geolocation. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'supporting-tunnel-termination-point': ( + supporting_tunnel_termination_point := ( # YANGListMember( + TunnelTerminationPointMeta. + SupportingTunnelTerminationPoint. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TunnelTerminationPoint': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..38f9ec314a9426a5fe03975be29a2e28b422a31e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ClientLayerAdaptationMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: client-layer-adaptation + """ + from .switching_capability import SwitchingCapability + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: client-layer-adaptation + """ + + def __init__(self): + super().__init__(ClientLayerAdaptation) + + def __get__(self, instance, owner=None) -> ( + 'ClientLayerAdaptationMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ClientLayerAdaptation': + pass + + def __enter__(self) -> 'ClientLayerAdaptation': + pass + + +class ClientLayerAdaptation( + YANGContainer, + metaclass=ClientLayerAdaptationMeta): + """ + YANG container handler. + + YANG name: client-layer-adaptation + """ + + _yang_name: Final[str] = 'client-layer-adaptation' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'switching-capability': ( + switching_capability := ( # YANGListMember( + ClientLayerAdaptationMeta. + SwitchingCapability. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ClientLayerAdaptation': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..74c496e9c8505568c18ca8db338e3c313884945d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/__init__.py @@ -0,0 +1,110 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SwitchingCapabilityMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: switching-capability + """ + from .te_bandwidth import TeBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: switching-capability + """ + + def __init__(self): + super().__init__(SwitchingCapability) + + def __get__(self, instance, owner=None) -> ( + 'SwitchingCapabilityMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['SwitchingCapability']: + pass + + def __iter__(self, key) -> Iterator['SwitchingCapability']: + return super().__iter__() + + def __getitem__(self, key) -> 'SwitchingCapability': + return super()[key] + + def __enter__(self) -> ( + 'SwitchingCapabilityMeta.yang_list_descriptor'): + pass + + +class SwitchingCapability( + YANGListItem, + metaclass=SwitchingCapabilityMeta): + """ + YANG list item handler. + + YANG name: switching-capability + """ + + _yang_name: Final[str] = 'switching-capability' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'switching-capability', + 'encoding', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'switching-capability': ( + switching_capability := YANGLeafMember( + 'switching-capability', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'encoding': ( + encoding := YANGLeafMember( + 'encoding', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + SwitchingCapabilityMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SwitchingCapability': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/client_layer_adaptation/switching_capability/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/geolocation/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/geolocation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e58eb1516669a36eac9abd5451d7335da8de62a4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/geolocation/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GeolocationMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: geolocation + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: geolocation + """ + + def __init__(self): + super().__init__(Geolocation) + + def __get__(self, instance, owner=None) -> ( + 'GeolocationMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Geolocation': + pass + + def __enter__(self) -> 'Geolocation': + pass + + +class Geolocation( + YANGContainer, + metaclass=GeolocationMeta): + """ + YANG container handler. + + YANG name: geolocation + """ + + _yang_name: Final[str] = 'geolocation' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'latitude': ( + latitude := YANGLeafMember( + 'latitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'longitude': ( + longitude := YANGLeafMember( + 'longitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'altitude': ( + altitude := YANGLeafMember( + 'altitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Geolocation': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d107aca7146b13039b609d38c023443bfe120a37 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/__init__.py @@ -0,0 +1,133 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LocalLinkConnectivitiesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: local-link-connectivities + """ + from .underlay import Underlay + from .path_constraints import PathConstraints + from .path_properties import PathProperties + from .label_restrictions import LabelRestrictions + from .optimizations import Optimizations + from .local_link_connectivity import LocalLinkConnectivity + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: local-link-connectivities + """ + + def __init__(self): + super().__init__(LocalLinkConnectivities) + + def __get__(self, instance, owner=None) -> ( + 'LocalLinkConnectivitiesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LocalLinkConnectivities': + pass + + def __enter__(self) -> 'LocalLinkConnectivities': + pass + + +class LocalLinkConnectivities( + YANGContainer, + metaclass=LocalLinkConnectivitiesMeta): + """ + YANG container handler. + + YANG name: local-link-connectivities + """ + + _yang_name: Final[str] = 'local-link-connectivities' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'is-allowed': ( + is_allowed := YANGLeafMember( + 'is-allowed', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'number-of-entries': ( + number_of_entries := YANGLeafMember( + 'number-of-entries', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'underlay': ( + underlay := ( # YANGContainerMember( + LocalLinkConnectivitiesMeta. + Underlay. + yang_container_descriptor())), + + 'path-constraints': ( + path_constraints := ( # YANGContainerMember( + LocalLinkConnectivitiesMeta. + PathConstraints. + yang_container_descriptor())), + + 'path-properties': ( + path_properties := ( # YANGContainerMember( + LocalLinkConnectivitiesMeta. + PathProperties. + yang_container_descriptor())), + + 'label-restrictions': ( + label_restrictions := ( # YANGContainerMember( + LocalLinkConnectivitiesMeta. + LabelRestrictions. + yang_container_descriptor())), + + 'optimizations': ( + optimizations := ( # YANGContainerMember( + LocalLinkConnectivitiesMeta. + Optimizations. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'local-link-connectivity': ( + local_link_connectivity := ( # YANGListMember( + LocalLinkConnectivitiesMeta. + LocalLinkConnectivity. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LocalLinkConnectivities': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29f30ca794c567238bb34de6d5de219f72b68cca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-restrictions + """ + from .label_restriction import LabelRestriction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-restrictions + """ + + def __init__(self): + super().__init__(LabelRestrictions) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelRestrictions': + pass + + def __enter__(self) -> 'LabelRestrictions': + pass + + +class LabelRestrictions( + YANGContainer, + metaclass=LabelRestrictionsMeta): + """ + YANG container handler. + + YANG name: label-restrictions + """ + + _yang_name: Final[str] = 'label-restrictions' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'label-restriction': ( + label_restriction := ( # YANGListMember( + LabelRestrictionsMeta. + LabelRestriction. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestrictions': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..814ea59a555c0c31d59f79bd58db695d0fb105e8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: label-restriction + """ + from .label_end import LabelEnd + from .label_start import LabelStart + from .label_step import LabelStep + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: label-restriction + """ + + def __init__(self): + super().__init__(LabelRestriction) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LabelRestriction']: + pass + + def __iter__(self, key) -> Iterator['LabelRestriction']: + return super().__iter__() + + def __getitem__(self, key) -> 'LabelRestriction': + return super()[key] + + def __enter__(self) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + pass + + +class LabelRestriction( + YANGListItem, + metaclass=LabelRestrictionMeta): + """ + YANG list item handler. + + YANG name: label-restriction + """ + + _yang_name: Final[str] = 'label-restriction' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restriction': ( + restriction := YANGLeafMember( + 'restriction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'range-bitmap': ( + range_bitmap := YANGLeafMember( + 'range-bitmap', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-end': ( + label_end := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelEnd. + yang_container_descriptor())), + + 'label-start': ( + label_start := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStart. + yang_container_descriptor())), + + 'label-step': ( + label_step := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStep. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestriction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ad525773e032b7b224f5b661e728ffe8950e98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelEndMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-end + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-end + """ + + def __init__(self): + super().__init__(LabelEnd) + + def __get__(self, instance, owner=None) -> ( + 'LabelEndMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelEnd': + pass + + def __enter__(self) -> 'LabelEnd': + pass + + +class LabelEnd( + YANGContainer, + metaclass=LabelEndMeta): + """ + YANG container handler. + + YANG name: label-end + """ + + _yang_name: Final[str] = 'label-end' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelEndMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelEnd': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8985523ba0c69fac8fbd1852bd47f2891d92bc6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStartMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-start + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-start + """ + + def __init__(self): + super().__init__(LabelStart) + + def __get__(self, instance, owner=None) -> ( + 'LabelStartMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStart': + pass + + def __enter__(self) -> 'LabelStart': + pass + + +class LabelStart( + YANGContainer, + metaclass=LabelStartMeta): + """ + YANG container handler. + + YANG name: label-start + """ + + _yang_name: Final[str] = 'label-start' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelStartMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStart': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d3aeed125a790da60e394f9e834fb871ab9c3b9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStepMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-step + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-step + """ + + def __init__(self): + super().__init__(LabelStep) + + def __get__(self, instance, owner=None) -> ( + 'LabelStepMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStep': + pass + + def __enter__(self) -> 'LabelStep': + pass + + +class LabelStep( + YANGContainer, + metaclass=LabelStepMeta): + """ + YANG container handler. + + YANG name: label-step + """ + + _yang_name: Final[str] = 'label-step' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStep': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + LabelStepMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + LabelStepMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/label_restrictions/label_restriction/label_step/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..89dc7a8809c12f5dc8f942f7719322884fea3b49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/__init__.py @@ -0,0 +1,137 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LocalLinkConnectivityMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: local-link-connectivity + """ + from .underlay import Underlay + from .optimizations import Optimizations + from .label_restrictions import LabelRestrictions + from .path_properties import PathProperties + from .path_constraints import PathConstraints + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: local-link-connectivity + """ + + def __init__(self): + super().__init__(LocalLinkConnectivity) + + def __get__(self, instance, owner=None) -> ( + 'LocalLinkConnectivityMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LocalLinkConnectivity']: + pass + + def __iter__(self, key) -> Iterator['LocalLinkConnectivity']: + return super().__iter__() + + def __getitem__(self, key) -> 'LocalLinkConnectivity': + return super()[key] + + def __enter__(self) -> ( + 'LocalLinkConnectivityMeta.yang_list_descriptor'): + pass + + +class LocalLinkConnectivity( + YANGListItem, + metaclass=LocalLinkConnectivityMeta): + """ + YANG list item handler. + + YANG name: local-link-connectivity + """ + + _yang_name: Final[str] = 'local-link-connectivity' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'link-tp-ref', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-ref': ( + link_tp_ref := YANGLeafMember( + 'link-tp-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'is-allowed': ( + is_allowed := YANGLeafMember( + 'is-allowed', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'underlay': ( + underlay := ( # YANGContainerMember( + LocalLinkConnectivityMeta. + Underlay. + yang_container_descriptor())), + + 'optimizations': ( + optimizations := ( # YANGContainerMember( + LocalLinkConnectivityMeta. + Optimizations. + yang_container_descriptor())), + + 'label-restrictions': ( + label_restrictions := ( # YANGContainerMember( + LocalLinkConnectivityMeta. + LabelRestrictions. + yang_container_descriptor())), + + 'path-properties': ( + path_properties := ( # YANGContainerMember( + LocalLinkConnectivityMeta. + PathProperties. + yang_container_descriptor())), + + 'path-constraints': ( + path_constraints := ( # YANGContainerMember( + LocalLinkConnectivityMeta. + PathConstraints. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LocalLinkConnectivity': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29f30ca794c567238bb34de6d5de219f72b68cca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-restrictions + """ + from .label_restriction import LabelRestriction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-restrictions + """ + + def __init__(self): + super().__init__(LabelRestrictions) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelRestrictions': + pass + + def __enter__(self) -> 'LabelRestrictions': + pass + + +class LabelRestrictions( + YANGContainer, + metaclass=LabelRestrictionsMeta): + """ + YANG container handler. + + YANG name: label-restrictions + """ + + _yang_name: Final[str] = 'label-restrictions' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'label-restriction': ( + label_restriction := ( # YANGListMember( + LabelRestrictionsMeta. + LabelRestriction. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestrictions': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1075ea1483389fe2d8a6245c8b19b16007859ffb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: label-restriction + """ + from .label_start import LabelStart + from .label_end import LabelEnd + from .label_step import LabelStep + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: label-restriction + """ + + def __init__(self): + super().__init__(LabelRestriction) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LabelRestriction']: + pass + + def __iter__(self, key) -> Iterator['LabelRestriction']: + return super().__iter__() + + def __getitem__(self, key) -> 'LabelRestriction': + return super()[key] + + def __enter__(self) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + pass + + +class LabelRestriction( + YANGListItem, + metaclass=LabelRestrictionMeta): + """ + YANG list item handler. + + YANG name: label-restriction + """ + + _yang_name: Final[str] = 'label-restriction' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'range-bitmap': ( + range_bitmap := YANGLeafMember( + 'range-bitmap', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restriction': ( + restriction := YANGLeafMember( + 'restriction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-start': ( + label_start := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStart. + yang_container_descriptor())), + + 'label-end': ( + label_end := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelEnd. + yang_container_descriptor())), + + 'label-step': ( + label_step := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStep. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestriction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ad525773e032b7b224f5b661e728ffe8950e98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelEndMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-end + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-end + """ + + def __init__(self): + super().__init__(LabelEnd) + + def __get__(self, instance, owner=None) -> ( + 'LabelEndMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelEnd': + pass + + def __enter__(self) -> 'LabelEnd': + pass + + +class LabelEnd( + YANGContainer, + metaclass=LabelEndMeta): + """ + YANG container handler. + + YANG name: label-end + """ + + _yang_name: Final[str] = 'label-end' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelEndMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelEnd': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8985523ba0c69fac8fbd1852bd47f2891d92bc6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStartMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-start + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-start + """ + + def __init__(self): + super().__init__(LabelStart) + + def __get__(self, instance, owner=None) -> ( + 'LabelStartMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStart': + pass + + def __enter__(self) -> 'LabelStart': + pass + + +class LabelStart( + YANGContainer, + metaclass=LabelStartMeta): + """ + YANG container handler. + + YANG name: label-start + """ + + _yang_name: Final[str] = 'label-start' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelStartMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStart': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d3aeed125a790da60e394f9e834fb871ab9c3b9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStepMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-step + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-step + """ + + def __init__(self): + super().__init__(LabelStep) + + def __get__(self, instance, owner=None) -> ( + 'LabelStepMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStep': + pass + + def __enter__(self) -> 'LabelStep': + pass + + +class LabelStep( + YANGContainer, + metaclass=LabelStepMeta): + """ + YANG container handler. + + YANG name: label-step + """ + + _yang_name: Final[str] = 'label-step' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStep': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + LabelStepMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + LabelStepMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/label_restrictions/label_restriction/label_step/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c8d4f4c8def0e90dabe399cc305dc3b8d3d500 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: optimizations + """ + from .algorithm import Algorithm + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: optimizations + """ + + def __init__(self): + super().__init__(Optimizations) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Optimizations': + pass + + def __enter__(self) -> 'Optimizations': + pass + + +class Optimizations( + YANGContainer, + metaclass=OptimizationsMeta): + """ + YANG container handler. + + YANG name: optimizations + """ + + _yang_name: Final[str] = 'optimizations' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Optimizations': + instance = super().__new__(cls) + instance._yang_choices = { + + 'algorithm': + OptimizationsMeta.Algorithm( + instance), + } + return instance + + @property + def algorithm(self) -> ( + OptimizationsMeta.Algorithm): + return self._yang_choices['algorithm'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9e0ca52a42ed25af1b7e0612d3e9a6b3d43b6ef9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/__init__.py @@ -0,0 +1,101 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AlgorithmMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: algorithm + """ + + from .objective_function import ObjectiveFunction + from .metric import Metric + + class objective_function_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.objective_function_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + class metric_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.Metric) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.metric_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + +class Algorithm(YANGChoice, metaclass=AlgorithmMeta): + """ + YANG choice handler. + + YANG name: algorithm + """ + + _yang_name: Final[str] = 'algorithm' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'objective-function': ( + objective_function := ( # YANGChoiceCase( + AlgorithmMeta. + objective_function_case_descriptor())), + + 'metric': ( + metric := ( # YANGChoiceCase( + AlgorithmMeta. + metric_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e7d1da8ee3719d0d6a3c401df7340fbd3517e8ed --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: metric + """ + from .tiebreakers import Tiebreakers + from .optimization_metric import OptimizationMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__(Metric) + + def __get__(self, instance, owner=None) -> ( + 'MetricMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Metric': + pass + + def __enter__(self) -> 'Metric': + pass + + +class Metric( + YANGContainer, + metaclass=MetricMeta): + """ + YANG container handler. + + YANG name: metric + """ + + _yang_name: Final[str] = 'metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'tiebreakers': ( + tiebreakers := ( # YANGContainerMember( + MetricMeta. + Tiebreakers. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'optimization-metric': ( + optimization_metric := ( # YANGListMember( + MetricMeta. + OptimizationMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Metric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e5e69ea24d5d4bc36b6bf78a13fb98a25a1e5916 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/__init__.py @@ -0,0 +1,116 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: optimization-metric + """ + from .explicit_route_exclude_objects import ExplicitRouteExcludeObjects + from .explicit_route_include_objects import ExplicitRouteIncludeObjects + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: optimization-metric + """ + + def __init__(self): + super().__init__(OptimizationMetric) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['OptimizationMetric']: + pass + + def __iter__(self, key) -> Iterator['OptimizationMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'OptimizationMetric': + return super()[key] + + def __enter__(self) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + pass + + +class OptimizationMetric( + YANGListItem, + metaclass=OptimizationMetricMeta): + """ + YANG list item handler. + + YANG name: optimization-metric + """ + + _yang_name: Final[str] = 'optimization-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'weight': ( + weight := YANGLeafMember( + 'weight', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'explicit-route-exclude-objects': ( + explicit_route_exclude_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteExcludeObjects. + yang_container_descriptor())), + + 'explicit-route-include-objects': ( + explicit_route_include_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteIncludeObjects. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'OptimizationMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aea7bdd4cd5ed1743a1764899878a1ac8035348e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteExcludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + from .route_object_exclude_object import RouteObjectExcludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-exclude-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteExcludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteExcludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteExcludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteExcludeObjects': + pass + + +class ExplicitRouteExcludeObjects( + YANGContainer, + metaclass=ExplicitRouteExcludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + + _yang_name: Final[str] = 'explicit-route-exclude-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-exclude-object': ( + route_object_exclude_object := ( # YANGListMember( + ExplicitRouteExcludeObjectsMeta. + RouteObjectExcludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteExcludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..405906d3e6d9dd1eda79aae3a6302c37e0e24988 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectExcludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-exclude-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-exclude-object + """ + + def __init__(self): + super().__init__(RouteObjectExcludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectExcludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectExcludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectExcludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectExcludeObject( + YANGListItem, + metaclass=RouteObjectExcludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-exclude-object + """ + + _yang_name: Final[str] = 'route-object-exclude-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectExcludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectExcludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectExcludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d71309cbb007ad744071cd2a2bbacb7964114efc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py @@ -0,0 +1,217 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .unnumbered_link_hop import UnnumberedLinkHop + from .label import Label + from .numbered_node_hop import NumberedNodeHop + from .numbered_link_hop import NumberedLinkHop + from .as_number import AsNumber + from .srlg import Srlg + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class srlg_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__( + TypeMeta.Srlg) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.srlg_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Srlg'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Srlg'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'srlg': ( + srlg := ( # YANGChoiceCase( + TypeMeta. + srlg_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c993df52db1f2e1aa1085a57856c8585fcba58 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..420f996a13a20bf122ec87f0fbb109b34246eb61 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + from .srlg import Srlg + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'srlg': ( + srlg := ( # YANGContainerMember( + SrlgMeta. + Srlg. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..95a1628e4caf545e0d31823f89ea93178ffb76c7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'srlg': ( + srlg := YANGLeafMember( + 'srlg', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..07c0b7b779289a6ac9a9123fd540526dc6d190fb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3209b99bad73493077e9e91a8053f320b05c11c0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteIncludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-include-objects + """ + from .route_object_include_object import RouteObjectIncludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-include-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteIncludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteIncludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteIncludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteIncludeObjects': + pass + + +class ExplicitRouteIncludeObjects( + YANGContainer, + metaclass=ExplicitRouteIncludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-include-objects + """ + + _yang_name: Final[str] = 'explicit-route-include-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-include-object': ( + route_object_include_object := ( # YANGListMember( + ExplicitRouteIncludeObjectsMeta. + RouteObjectIncludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteIncludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c9f24330ff35e20e47be0db730f6ec682dd71d2d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectIncludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-include-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-include-object + """ + + def __init__(self): + super().__init__(RouteObjectIncludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectIncludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectIncludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectIncludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectIncludeObject( + YANGListItem, + metaclass=RouteObjectIncludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-include-object + """ + + _yang_name: Final[str] = 'route-object-include-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectIncludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectIncludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectIncludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..97c7b52d53563f340bcf3adef447aa2d718ee50b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .label import Label + from .unnumbered_link_hop import UnnumberedLinkHop + from .numbered_link_hop import NumberedLinkHop + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8d9d3d58559fab79fa12a634fb4aecbef61780f1 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..07c0b7b779289a6ac9a9123fd540526dc6d190fb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/tiebreakers/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/tiebreakers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d345b57b342afaa50a04c5782794f34b810b795c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/tiebreakers/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakersMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tiebreakers + """ + from .tiebreaker import Tiebreaker + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tiebreakers + """ + + def __init__(self): + super().__init__(Tiebreakers) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakersMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tiebreakers': + pass + + def __enter__(self) -> 'Tiebreakers': + pass + + +class Tiebreakers( + YANGContainer, + metaclass=TiebreakersMeta): + """ + YANG container handler. + + YANG name: tiebreakers + """ + + _yang_name: Final[str] = 'tiebreakers' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tiebreaker': ( + tiebreaker := ( # YANGListMember( + TiebreakersMeta. + Tiebreaker. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreakers': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..500d880ad6ad48b8079aa3bea0b1e644f7008f49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakerMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tiebreaker + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tiebreaker + """ + + def __init__(self): + super().__init__(Tiebreaker) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tiebreaker']: + pass + + def __iter__(self, key) -> Iterator['Tiebreaker']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tiebreaker': + return super()[key] + + def __enter__(self) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + pass + + +class Tiebreaker( + YANGListItem, + metaclass=TiebreakerMeta): + """ + YANG list item handler. + + YANG name: tiebreaker + """ + + _yang_name: Final[str] = 'tiebreaker' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tiebreaker-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tiebreaker-type': ( + tiebreaker_type := YANGLeafMember( + 'tiebreaker-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreaker': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbd32a2bb98c6e47f795103fbc122cbf7957e1e6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/objective_function/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + from .objective_function import ObjectiveFunction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'objective-function': ( + objective_function := ( # YANGContainerMember( + ObjectiveFunctionMeta. + ObjectiveFunction. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/objective_function/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/objective_function/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..af72bcf2702ccee1d360bad39000241d1abfdc19 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/optimizations/algorithm/objective_function/objective_function/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'objective-function-type': ( + objective_function_type := YANGLeafMember( + 'objective-function-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4ffa7b66e87daa14eb143c6501aa376cc779aed5 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/__init__.py @@ -0,0 +1,151 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-constraints + """ + from .path_srlgs_names import PathSrlgsNames + from .path_affinities_values import PathAffinitiesValues + from .path_srlgs_lists import PathSrlgsLists + from .path_metric_bounds import PathMetricBounds + from .te_bandwidth import TeBandwidth + from .path_affinity_names import PathAffinityNames + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-constraints + """ + + def __init__(self): + super().__init__(PathConstraints) + + def __get__(self, instance, owner=None) -> ( + 'PathConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathConstraints': + pass + + def __enter__(self) -> 'PathConstraints': + pass + + +class PathConstraints( + YANGContainer, + metaclass=PathConstraintsMeta): + """ + YANG container handler. + + YANG name: path-constraints + """ + + _yang_name: Final[str] = 'path-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'setup-priority': ( + setup_priority := YANGLeafMember( + 'setup-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-protection': ( + link_protection := YANGLeafMember( + 'link-protection', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'disjointness': ( + disjointness := YANGLeafMember( + 'disjointness', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'signaling-type': ( + signaling_type := YANGLeafMember( + 'signaling-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hold-priority': ( + hold_priority := YANGLeafMember( + 'hold-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsNames. + yang_container_descriptor())), + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinitiesValues. + yang_container_descriptor())), + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-metric-bounds': ( + path_metric_bounds := ( # YANGContainerMember( + PathConstraintsMeta. + PathMetricBounds. + yang_container_descriptor())), + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + PathConstraintsMeta. + TeBandwidth. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinityNames. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7560d7f51b4174c036b96d1a6599a2a3ada8d674 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..356f7761b99b2e313b0638407dbaaa3996e6c418 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-metric-bounds + """ + from .path_metric_bound import PathMetricBound + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-metric-bounds + """ + + def __init__(self): + super().__init__(PathMetricBounds) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathMetricBounds': + pass + + def __enter__(self) -> 'PathMetricBounds': + pass + + +class PathMetricBounds( + YANGContainer, + metaclass=PathMetricBoundsMeta): + """ + YANG container handler. + + YANG name: path-metric-bounds + """ + + _yang_name: Final[str] = 'path-metric-bounds' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric-bound': ( + path_metric_bound := ( # YANGListMember( + PathMetricBoundsMeta. + PathMetricBound. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBounds': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/path_metric_bound/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/path_metric_bound/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e6e72a44fd364b7d9238cef98eba888090a23f76 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_metric_bounds/path_metric_bound/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric-bound + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric-bound + """ + + def __init__(self): + super().__init__(PathMetricBound) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetricBound']: + pass + + def __iter__(self, key) -> Iterator['PathMetricBound']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetricBound': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + pass + + +class PathMetricBound( + YANGListItem, + metaclass=PathMetricBoundMeta): + """ + YANG list item handler. + + YANG name: path-metric-bound + """ + + _yang_name: Final[str] = 'path-metric-bound' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'upper-bound': ( + upper_bound := YANGLeafMember( + 'upper-bound', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBound': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_constraints/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bde8f98e58827b2019a01b80cad4ec0198201e72 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/__init__.py @@ -0,0 +1,121 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathPropertiesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-properties + """ + from .path_srlgs_lists import PathSrlgsLists + from .path_srlgs_names import PathSrlgsNames + from .path_affinities_values import PathAffinitiesValues + from .path_affinity_names import PathAffinityNames + from .path_route_objects import PathRouteObjects + from .path_metric import PathMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-properties + """ + + def __init__(self): + super().__init__(PathProperties) + + def __get__(self, instance, owner=None) -> ( + 'PathPropertiesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathProperties': + pass + + def __enter__(self) -> 'PathProperties': + pass + + +class PathProperties( + YANGContainer, + metaclass=PathPropertiesMeta): + """ + YANG container handler. + + YANG name: path-properties + """ + + _yang_name: Final[str] = 'path-properties' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsNames. + yang_container_descriptor())), + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinitiesValues. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinityNames. + yang_container_descriptor())), + + 'path-route-objects': ( + path_route_objects := ( # YANGContainerMember( + PathPropertiesMeta. + PathRouteObjects. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric': ( + path_metric := ( # YANGListMember( + PathPropertiesMeta. + PathMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathProperties': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7560d7f51b4174c036b96d1a6599a2a3ada8d674 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7645abedd4d25aeb9c77aa579c2972a450d00a6e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_metric/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric + """ + + def __init__(self): + super().__init__(PathMetric) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetric']: + pass + + def __iter__(self, key) -> Iterator['PathMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetric': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricMeta.yang_list_descriptor'): + pass + + +class PathMetric( + YANGListItem, + metaclass=PathMetricMeta): + """ + YANG list item handler. + + YANG name: path-metric + """ + + _yang_name: Final[str] = 'path-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'accumulative-value': ( + accumulative_value := YANGLeafMember( + 'accumulative-value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2af8eb3f47d7b0ceb2d21f9f5b1ee44b432ab35f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-route-objects + """ + from .path_route_object import PathRouteObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-route-objects + """ + + def __init__(self): + super().__init__(PathRouteObjects) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathRouteObjects': + pass + + def __enter__(self) -> 'PathRouteObjects': + pass + + +class PathRouteObjects( + YANGContainer, + metaclass=PathRouteObjectsMeta): + """ + YANG container handler. + + YANG name: path-route-objects + """ + + _yang_name: Final[str] = 'path-route-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-route-object': ( + path_route_object := ( # YANGListMember( + PathRouteObjectsMeta. + PathRouteObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..74b9e21c769902d7a2bb1f362d2e95cbf5d862cd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-route-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-route-object + """ + + def __init__(self): + super().__init__(PathRouteObject) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathRouteObject']: + pass + + def __iter__(self, key) -> Iterator['PathRouteObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathRouteObject': + return super()[key] + + def __enter__(self) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + pass + + +class PathRouteObject( + YANGListItem, + metaclass=PathRouteObjectMeta): + """ + YANG list item handler. + + YANG name: path-route-object + """ + + _yang_name: Final[str] = 'path-route-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathRouteObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathRouteObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ce99e420e4339dbff19a79559a99828a5632ed52 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .unnumbered_link_hop import UnnumberedLinkHop + from .label import Label + from .numbered_link_hop import NumberedLinkHop + from .numbered_node_hop import NumberedNodeHop + from .as_number import AsNumber + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1abedb4d3f8145943387f3e66e3e17fed741dcdc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7de25b7bbfed705b63d9c681cad27d7bd9b9584d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/path_properties/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..718667143f90b280fcd63585a43ec31bd9555933 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/__init__.py @@ -0,0 +1,119 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay + """ + from .tunnels import Tunnels + from .primary_path import PrimaryPath + from .tunnel_termination_points import TunnelTerminationPoints + from .backup_path import BackupPath + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay + """ + + def __init__(self): + super().__init__(Underlay) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Underlay': + pass + + def __enter__(self) -> 'Underlay': + pass + + +class Underlay( + YANGContainer, + metaclass=UnderlayMeta): + """ + YANG container handler. + + YANG name: underlay + """ + + _yang_name: Final[str] = 'underlay' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'protection-type': ( + protection_type := YANGLeafMember( + 'protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'enabled': ( + enabled := YANGLeafMember( + 'enabled', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'tunnels': ( + tunnels := ( # YANGContainerMember( + UnderlayMeta. + Tunnels. + yang_container_descriptor())), + + 'primary-path': ( + primary_path := ( # YANGContainerMember( + UnderlayMeta. + PrimaryPath. + yang_container_descriptor())), + + 'tunnel-termination-points': ( + tunnel_termination_points := ( # YANGContainerMember( + UnderlayMeta. + TunnelTerminationPoints. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'backup-path': ( + backup_path := ( # YANGListMember( + UnderlayMeta. + BackupPath. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Underlay': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6b6e1ff5cb9da5f8c265df0f8c0854de089ff9ef --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/__init__.py @@ -0,0 +1,109 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BackupPathMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: backup-path + """ + from .path_element import PathElement + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: backup-path + """ + + def __init__(self): + super().__init__(BackupPath) + + def __get__(self, instance, owner=None) -> ( + 'BackupPathMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['BackupPath']: + pass + + def __iter__(self, key) -> Iterator['BackupPath']: + return super().__iter__() + + def __getitem__(self, key) -> 'BackupPath': + return super()[key] + + def __enter__(self) -> ( + 'BackupPathMeta.yang_list_descriptor'): + pass + + +class BackupPath( + YANGListItem, + metaclass=BackupPathMeta): + """ + YANG list item handler. + + YANG name: backup-path + """ + + _yang_name: Final[str] = 'backup-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + BackupPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'BackupPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d1ab68ff674ea58adde5a644c74609928fe6f874 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_node_hop import NumberedNodeHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + from .label import Label + from .numbered_link_hop import NumberedLinkHop + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..64a8ec6d5e2fd4a77c59c13b3e37cacb001c91fe --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1182654a4bf2eb5a4496796aa2c9752309208f46 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..34a2a729ce6d45e11174065699c428a7ac677a8b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PrimaryPathMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: primary-path + """ + from .path_element import PathElement + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: primary-path + """ + + def __init__(self): + super().__init__(PrimaryPath) + + def __get__(self, instance, owner=None) -> ( + 'PrimaryPathMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PrimaryPath': + pass + + def __enter__(self) -> 'PrimaryPath': + pass + + +class PrimaryPath( + YANGContainer, + metaclass=PrimaryPathMeta): + """ + YANG container handler. + + YANG name: primary-path + """ + + _yang_name: Final[str] = 'primary-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + PrimaryPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PrimaryPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2961e2bf8c581c42005442bebf3b91dd7424a524 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_node_hop import NumberedNodeHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .label import Label + from .numbered_link_hop import NumberedLinkHop + from .as_number import AsNumber + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1abedb4d3f8145943387f3e66e3e17fed741dcdc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..088a2a9a5842516b7391cf36f8c90e94028a03d5 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnel_termination_points/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnel_termination_points/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8ae8cc268f3c4fc331cd1e1018be41d113da9183 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnel_termination_points/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelTerminationPointsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnel-termination-points + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnel-termination-points + """ + + def __init__(self): + super().__init__(TunnelTerminationPoints) + + def __get__(self, instance, owner=None) -> ( + 'TunnelTerminationPointsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TunnelTerminationPoints': + pass + + def __enter__(self) -> 'TunnelTerminationPoints': + pass + + +class TunnelTerminationPoints( + YANGContainer, + metaclass=TunnelTerminationPointsMeta): + """ + YANG container handler. + + YANG name: tunnel-termination-points + """ + + _yang_name: Final[str] = 'tunnel-termination-points' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'source': ( + source := YANGLeafMember( + 'source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'destination': ( + destination := YANGLeafMember( + 'destination', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TunnelTerminationPoints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..303858f3e0c28faecf9696d2fbf403d5510cced8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnels + """ + from .tunnel import Tunnel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnels + """ + + def __init__(self): + super().__init__(Tunnels) + + def __get__(self, instance, owner=None) -> ( + 'TunnelsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tunnels': + pass + + def __enter__(self) -> 'Tunnels': + pass + + +class Tunnels( + YANGContainer, + metaclass=TunnelsMeta): + """ + YANG container handler. + + YANG name: tunnels + """ + + _yang_name: Final[str] = 'tunnels' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tunnel': ( + tunnel := ( # YANGListMember( + TunnelsMeta. + Tunnel. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnels': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/tunnel/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/tunnel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d36aa35acd17db473e177b143afdec573f0b4927 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/local_link_connectivity/underlay/tunnels/tunnel/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tunnel + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tunnel + """ + + def __init__(self): + super().__init__(Tunnel) + + def __get__(self, instance, owner=None) -> ( + 'TunnelMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tunnel']: + pass + + def __iter__(self, key) -> Iterator['Tunnel']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tunnel': + return super()[key] + + def __enter__(self) -> ( + 'TunnelMeta.yang_list_descriptor'): + pass + + +class Tunnel( + YANGListItem, + metaclass=TunnelMeta): + """ + YANG list item handler. + + YANG name: tunnel + """ + + _yang_name: Final[str] = 'tunnel' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tunnel-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tunnel-name': ( + tunnel_name := YANGLeafMember( + 'tunnel-name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnel': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c8d4f4c8def0e90dabe399cc305dc3b8d3d500 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: optimizations + """ + from .algorithm import Algorithm + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: optimizations + """ + + def __init__(self): + super().__init__(Optimizations) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Optimizations': + pass + + def __enter__(self) -> 'Optimizations': + pass + + +class Optimizations( + YANGContainer, + metaclass=OptimizationsMeta): + """ + YANG container handler. + + YANG name: optimizations + """ + + _yang_name: Final[str] = 'optimizations' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Optimizations': + instance = super().__new__(cls) + instance._yang_choices = { + + 'algorithm': + OptimizationsMeta.Algorithm( + instance), + } + return instance + + @property + def algorithm(self) -> ( + OptimizationsMeta.Algorithm): + return self._yang_choices['algorithm'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9e0ca52a42ed25af1b7e0612d3e9a6b3d43b6ef9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/__init__.py @@ -0,0 +1,101 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AlgorithmMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: algorithm + """ + + from .objective_function import ObjectiveFunction + from .metric import Metric + + class objective_function_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.objective_function_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.ObjectiveFunction'): + pass + + class metric_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__( + AlgorithmMeta.Metric) + + def __get__(self, instance, owner=None) -> ( + 'AlgorithmMeta.metric_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + def __enter__(self) -> ( + 'AlgorithmMeta.Metric'): + pass + + +class Algorithm(YANGChoice, metaclass=AlgorithmMeta): + """ + YANG choice handler. + + YANG name: algorithm + """ + + _yang_name: Final[str] = 'algorithm' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'objective-function': ( + objective_function := ( # YANGChoiceCase( + AlgorithmMeta. + objective_function_case_descriptor())), + + 'metric': ( + metric := ( # YANGChoiceCase( + AlgorithmMeta. + metric_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e7d1da8ee3719d0d6a3c401df7340fbd3517e8ed --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MetricMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: metric + """ + from .tiebreakers import Tiebreakers + from .optimization_metric import OptimizationMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: metric + """ + + def __init__(self): + super().__init__(Metric) + + def __get__(self, instance, owner=None) -> ( + 'MetricMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Metric': + pass + + def __enter__(self) -> 'Metric': + pass + + +class Metric( + YANGContainer, + metaclass=MetricMeta): + """ + YANG container handler. + + YANG name: metric + """ + + _yang_name: Final[str] = 'metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'tiebreakers': ( + tiebreakers := ( # YANGContainerMember( + MetricMeta. + Tiebreakers. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'optimization-metric': ( + optimization_metric := ( # YANGListMember( + MetricMeta. + OptimizationMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Metric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e0b3f85a0993ca8184c4cec6a891f373b0666767 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/__init__.py @@ -0,0 +1,116 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class OptimizationMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: optimization-metric + """ + from .explicit_route_include_objects import ExplicitRouteIncludeObjects + from .explicit_route_exclude_objects import ExplicitRouteExcludeObjects + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: optimization-metric + """ + + def __init__(self): + super().__init__(OptimizationMetric) + + def __get__(self, instance, owner=None) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['OptimizationMetric']: + pass + + def __iter__(self, key) -> Iterator['OptimizationMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'OptimizationMetric': + return super()[key] + + def __enter__(self) -> ( + 'OptimizationMetricMeta.yang_list_descriptor'): + pass + + +class OptimizationMetric( + YANGListItem, + metaclass=OptimizationMetricMeta): + """ + YANG list item handler. + + YANG name: optimization-metric + """ + + _yang_name: Final[str] = 'optimization-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'weight': ( + weight := YANGLeafMember( + 'weight', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'explicit-route-include-objects': ( + explicit_route_include_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteIncludeObjects. + yang_container_descriptor())), + + 'explicit-route-exclude-objects': ( + explicit_route_exclude_objects := ( # YANGContainerMember( + OptimizationMetricMeta. + ExplicitRouteExcludeObjects. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'OptimizationMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aea7bdd4cd5ed1743a1764899878a1ac8035348e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteExcludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + from .route_object_exclude_object import RouteObjectExcludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-exclude-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteExcludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteExcludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteExcludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteExcludeObjects': + pass + + +class ExplicitRouteExcludeObjects( + YANGContainer, + metaclass=ExplicitRouteExcludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-exclude-objects + """ + + _yang_name: Final[str] = 'explicit-route-exclude-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-exclude-object': ( + route_object_exclude_object := ( # YANGListMember( + ExplicitRouteExcludeObjectsMeta. + RouteObjectExcludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteExcludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..405906d3e6d9dd1eda79aae3a6302c37e0e24988 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectExcludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-exclude-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-exclude-object + """ + + def __init__(self): + super().__init__(RouteObjectExcludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectExcludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectExcludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectExcludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectExcludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectExcludeObject( + YANGListItem, + metaclass=RouteObjectExcludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-exclude-object + """ + + _yang_name: Final[str] = 'route-object-exclude-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectExcludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectExcludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectExcludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ef448f1cfb4766cf527a00e8da8e1a261466c995 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/__init__.py @@ -0,0 +1,217 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .srlg import Srlg + from .numbered_node_hop import NumberedNodeHop + from .numbered_link_hop import NumberedLinkHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + from .label import Label + + class srlg_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__( + TypeMeta.Srlg) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.srlg_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Srlg'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Srlg'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'srlg': ( + srlg := ( # YANGChoiceCase( + TypeMeta. + srlg_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1cb78075b80ccd8887818376324a016daf17b67c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..420f996a13a20bf122ec87f0fbb109b34246eb61 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + from .srlg import Srlg + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'srlg': ( + srlg := ( # YANGContainerMember( + SrlgMeta. + Srlg. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..95a1628e4caf545e0d31823f89ea93178ffb76c7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/srlg/srlg/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SrlgMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: srlg + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: srlg + """ + + def __init__(self): + super().__init__(Srlg) + + def __get__(self, instance, owner=None) -> ( + 'SrlgMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Srlg': + pass + + def __enter__(self) -> 'Srlg': + pass + + +class Srlg( + YANGContainer, + metaclass=SrlgMeta): + """ + YANG container handler. + + YANG name: srlg + """ + + _yang_name: Final[str] = 'srlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'srlg': ( + srlg := YANGLeafMember( + 'srlg', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Srlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8ee74a2b7c7f647d2a88dfb22f44ed0ec1e80e4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_exclude_objects/route_object_exclude_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3209b99bad73493077e9e91a8053f320b05c11c0 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExplicitRouteIncludeObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: explicit-route-include-objects + """ + from .route_object_include_object import RouteObjectIncludeObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: explicit-route-include-objects + """ + + def __init__(self): + super().__init__(ExplicitRouteIncludeObjects) + + def __get__(self, instance, owner=None) -> ( + 'ExplicitRouteIncludeObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExplicitRouteIncludeObjects': + pass + + def __enter__(self) -> 'ExplicitRouteIncludeObjects': + pass + + +class ExplicitRouteIncludeObjects( + YANGContainer, + metaclass=ExplicitRouteIncludeObjectsMeta): + """ + YANG container handler. + + YANG name: explicit-route-include-objects + """ + + _yang_name: Final[str] = 'explicit-route-include-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'route-object-include-object': ( + route_object_include_object := ( # YANGListMember( + ExplicitRouteIncludeObjectsMeta. + RouteObjectIncludeObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExplicitRouteIncludeObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c9f24330ff35e20e47be0db730f6ec682dd71d2d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class RouteObjectIncludeObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: route-object-include-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: route-object-include-object + """ + + def __init__(self): + super().__init__(RouteObjectIncludeObject) + + def __get__(self, instance, owner=None) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['RouteObjectIncludeObject']: + pass + + def __iter__(self, key) -> Iterator['RouteObjectIncludeObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'RouteObjectIncludeObject': + return super()[key] + + def __enter__(self) -> ( + 'RouteObjectIncludeObjectMeta.yang_list_descriptor'): + pass + + +class RouteObjectIncludeObject( + YANGListItem, + metaclass=RouteObjectIncludeObjectMeta): + """ + YANG list item handler. + + YANG name: route-object-include-object + """ + + _yang_name: Final[str] = 'route-object-include-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'RouteObjectIncludeObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + RouteObjectIncludeObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + RouteObjectIncludeObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..943ba0bd2ef587976729a620de43a51d18612462 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_link_hop import NumberedLinkHop + from .numbered_node_hop import NumberedNodeHop + from .label import Label + from .as_number import AsNumber + from .unnumbered_link_hop import UnnumberedLinkHop + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1cb78075b80ccd8887818376324a016daf17b67c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ad1ed06e7edbba03876800aa1f46233860ec8b0d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/optimization_metric/explicit_route_include_objects/route_object_include_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/tiebreakers/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/tiebreakers/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d345b57b342afaa50a04c5782794f34b810b795c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/tiebreakers/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakersMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tiebreakers + """ + from .tiebreaker import Tiebreaker + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tiebreakers + """ + + def __init__(self): + super().__init__(Tiebreakers) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakersMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tiebreakers': + pass + + def __enter__(self) -> 'Tiebreakers': + pass + + +class Tiebreakers( + YANGContainer, + metaclass=TiebreakersMeta): + """ + YANG container handler. + + YANG name: tiebreakers + """ + + _yang_name: Final[str] = 'tiebreakers' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tiebreaker': ( + tiebreaker := ( # YANGListMember( + TiebreakersMeta. + Tiebreaker. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreakers': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..500d880ad6ad48b8079aa3bea0b1e644f7008f49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/metric/tiebreakers/tiebreaker/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TiebreakerMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tiebreaker + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tiebreaker + """ + + def __init__(self): + super().__init__(Tiebreaker) + + def __get__(self, instance, owner=None) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tiebreaker']: + pass + + def __iter__(self, key) -> Iterator['Tiebreaker']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tiebreaker': + return super()[key] + + def __enter__(self) -> ( + 'TiebreakerMeta.yang_list_descriptor'): + pass + + +class Tiebreaker( + YANGListItem, + metaclass=TiebreakerMeta): + """ + YANG list item handler. + + YANG name: tiebreaker + """ + + _yang_name: Final[str] = 'tiebreaker' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tiebreaker-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tiebreaker-type': ( + tiebreaker_type := YANGLeafMember( + 'tiebreaker-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tiebreaker': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbd32a2bb98c6e47f795103fbc122cbf7957e1e6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/objective_function/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + from .objective_function import ObjectiveFunction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'objective-function': ( + objective_function := ( # YANGContainerMember( + ObjectiveFunctionMeta. + ObjectiveFunction. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/objective_function/objective_function/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/objective_function/objective_function/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..af72bcf2702ccee1d360bad39000241d1abfdc19 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/optimizations/algorithm/objective_function/objective_function/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ObjectiveFunctionMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: objective-function + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: objective-function + """ + + def __init__(self): + super().__init__(ObjectiveFunction) + + def __get__(self, instance, owner=None) -> ( + 'ObjectiveFunctionMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ObjectiveFunction': + pass + + def __enter__(self) -> 'ObjectiveFunction': + pass + + +class ObjectiveFunction( + YANGContainer, + metaclass=ObjectiveFunctionMeta): + """ + YANG container handler. + + YANG name: objective-function + """ + + _yang_name: Final[str] = 'objective-function' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'objective-function-type': ( + objective_function_type := YANGLeafMember( + 'objective-function-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ObjectiveFunction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c83cf0a2d0df81953e96e2a55fde9fd16c751d0a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/__init__.py @@ -0,0 +1,151 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathConstraintsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-constraints + """ + from .path_affinities_values import PathAffinitiesValues + from .path_srlgs_lists import PathSrlgsLists + from .path_metric_bounds import PathMetricBounds + from .path_srlgs_names import PathSrlgsNames + from .path_affinity_names import PathAffinityNames + from .te_bandwidth import TeBandwidth + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-constraints + """ + + def __init__(self): + super().__init__(PathConstraints) + + def __get__(self, instance, owner=None) -> ( + 'PathConstraintsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathConstraints': + pass + + def __enter__(self) -> 'PathConstraints': + pass + + +class PathConstraints( + YANGContainer, + metaclass=PathConstraintsMeta): + """ + YANG container handler. + + YANG name: path-constraints + """ + + _yang_name: Final[str] = 'path-constraints' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hold-priority': ( + hold_priority := YANGLeafMember( + 'hold-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'setup-priority': ( + setup_priority := YANGLeafMember( + 'setup-priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'signaling-type': ( + signaling_type := YANGLeafMember( + 'signaling-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'disjointness': ( + disjointness := YANGLeafMember( + 'disjointness', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-protection': ( + link_protection := YANGLeafMember( + 'link-protection', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinitiesValues. + yang_container_descriptor())), + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-metric-bounds': ( + path_metric_bounds := ( # YANGContainerMember( + PathConstraintsMeta. + PathMetricBounds. + yang_container_descriptor())), + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathSrlgsNames. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathConstraintsMeta. + PathAffinityNames. + yang_container_descriptor())), + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + PathConstraintsMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathConstraints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d0e4a21b11accc2103aa85169cb46c386658d5cc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_metric_bounds/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_metric_bounds/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..356f7761b99b2e313b0638407dbaaa3996e6c418 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_metric_bounds/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-metric-bounds + """ + from .path_metric_bound import PathMetricBound + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-metric-bounds + """ + + def __init__(self): + super().__init__(PathMetricBounds) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathMetricBounds': + pass + + def __enter__(self) -> 'PathMetricBounds': + pass + + +class PathMetricBounds( + YANGContainer, + metaclass=PathMetricBoundsMeta): + """ + YANG container handler. + + YANG name: path-metric-bounds + """ + + _yang_name: Final[str] = 'path-metric-bounds' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric-bound': ( + path_metric_bound := ( # YANGListMember( + PathMetricBoundsMeta. + PathMetricBound. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBounds': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_metric_bounds/path_metric_bound/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_metric_bounds/path_metric_bound/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2a97d5e3e1d7066756b051d139f997d9a46b3c6b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_metric_bounds/path_metric_bound/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricBoundMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric-bound + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric-bound + """ + + def __init__(self): + super().__init__(PathMetricBound) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetricBound']: + pass + + def __iter__(self, key) -> Iterator['PathMetricBound']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetricBound': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricBoundMeta.yang_list_descriptor'): + pass + + +class PathMetricBound( + YANGListItem, + metaclass=PathMetricBoundMeta): + """ + YANG list item handler. + + YANG name: path-metric-bound + """ + + _yang_name: Final[str] = 'path-metric-bound' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'upper-bound': ( + upper_bound := YANGLeafMember( + 'upper-bound', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetricBound': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_constraints/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..41c96a46e00a42f281a1cdc712517006ccd5fa0b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/__init__.py @@ -0,0 +1,121 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathPropertiesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-properties + """ + from .path_route_objects import PathRouteObjects + from .path_affinity_names import PathAffinityNames + from .path_srlgs_lists import PathSrlgsLists + from .path_srlgs_names import PathSrlgsNames + from .path_affinities_values import PathAffinitiesValues + from .path_metric import PathMetric + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-properties + """ + + def __init__(self): + super().__init__(PathProperties) + + def __get__(self, instance, owner=None) -> ( + 'PathPropertiesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathProperties': + pass + + def __enter__(self) -> 'PathProperties': + pass + + +class PathProperties( + YANGContainer, + metaclass=PathPropertiesMeta): + """ + YANG container handler. + + YANG name: path-properties + """ + + _yang_name: Final[str] = 'path-properties' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'path-route-objects': ( + path_route_objects := ( # YANGContainerMember( + PathPropertiesMeta. + PathRouteObjects. + yang_container_descriptor())), + + 'path-affinity-names': ( + path_affinity_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinityNames. + yang_container_descriptor())), + + 'path-srlgs-lists': ( + path_srlgs_lists := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsLists. + yang_container_descriptor())), + + 'path-srlgs-names': ( + path_srlgs_names := ( # YANGContainerMember( + PathPropertiesMeta. + PathSrlgsNames. + yang_container_descriptor())), + + 'path-affinities-values': ( + path_affinities_values := ( # YANGContainerMember( + PathPropertiesMeta. + PathAffinitiesValues. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-metric': ( + path_metric := ( # YANGListMember( + PathPropertiesMeta. + PathMetric. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathProperties': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinities_values/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinities_values/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7c038ff21414923b939355bb6bdda825d64ece5a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinities_values/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValuesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinities-values + """ + from .path_affinities_value import PathAffinitiesValue + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinities-values + """ + + def __init__(self): + super().__init__(PathAffinitiesValues) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValuesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinitiesValues': + pass + + def __enter__(self) -> 'PathAffinitiesValues': + pass + + +class PathAffinitiesValues( + YANGContainer, + metaclass=PathAffinitiesValuesMeta): + """ + YANG container handler. + + YANG name: path-affinities-values + """ + + _yang_name: Final[str] = 'path-affinities-values' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinities-value': ( + path_affinities_value := ( # YANGListMember( + PathAffinitiesValuesMeta. + PathAffinitiesValue. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValues': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinities_values/path_affinities_value/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinities_values/path_affinities_value/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7560d7f51b4174c036b96d1a6599a2a3ada8d674 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinities_values/path_affinities_value/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinitiesValueMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinities-value + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinities-value + """ + + def __init__(self): + super().__init__(PathAffinitiesValue) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinitiesValue']: + pass + + def __iter__(self, key) -> Iterator['PathAffinitiesValue']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinitiesValue': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinitiesValueMeta.yang_list_descriptor'): + pass + + +class PathAffinitiesValue( + YANGListItem, + metaclass=PathAffinitiesValueMeta): + """ + YANG list item handler. + + YANG name: path-affinities-value + """ + + _yang_name: Final[str] = 'path-affinities-value' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'value': ( + value := YANGLeafMember( + 'value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinitiesValue': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinity_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinity_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a8439d312f2b42a7a09bb2b04e3c9207920fe69c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinity_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-affinity-names + """ + from .path_affinity_name import PathAffinityName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-affinity-names + """ + + def __init__(self): + super().__init__(PathAffinityNames) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathAffinityNames': + pass + + def __enter__(self) -> 'PathAffinityNames': + pass + + +class PathAffinityNames( + YANGContainer, + metaclass=PathAffinityNamesMeta): + """ + YANG container handler. + + YANG name: path-affinity-names + """ + + _yang_name: Final[str] = 'path-affinity-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-affinity-name': ( + path_affinity_name := ( # YANGListMember( + PathAffinityNamesMeta. + PathAffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinity_names/path_affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinity_names/path_affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f56a1940217a7ca828879399878fa57c2402196c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinity_names/path_affinity_name/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathAffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-affinity-name + """ + from .affinity_name import AffinityName + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-affinity-name + """ + + def __init__(self): + super().__init__(PathAffinityName) + + def __get__(self, instance, owner=None) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathAffinityName']: + pass + + def __iter__(self, key) -> Iterator['PathAffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathAffinityName': + return super()[key] + + def __enter__(self) -> ( + 'PathAffinityNameMeta.yang_list_descriptor'): + pass + + +class PathAffinityName( + YANGListItem, + metaclass=PathAffinityNameMeta): + """ + YANG list item handler. + + YANG name: path-affinity-name + """ + + _yang_name: Final[str] = 'path-affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'affinity-name': ( + affinity_name := ( # YANGListMember( + PathAffinityNameMeta. + AffinityName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathAffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75d22895c1b8c77e3c13ad584eaac74d23d0e359 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_affinity_names/path_affinity_name/affinity_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AffinityNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: affinity-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: affinity-name + """ + + def __init__(self): + super().__init__(AffinityName) + + def __get__(self, instance, owner=None) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['AffinityName']: + pass + + def __iter__(self, key) -> Iterator['AffinityName']: + return super().__iter__() + + def __getitem__(self, key) -> 'AffinityName': + return super()[key] + + def __enter__(self) -> ( + 'AffinityNameMeta.yang_list_descriptor'): + pass + + +class AffinityName( + YANGListItem, + metaclass=AffinityNameMeta): + """ + YANG list item handler. + + YANG name: affinity-name + """ + + _yang_name: Final[str] = 'affinity-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AffinityName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_metric/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_metric/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d6ae074074e7913854992f9bd32a8f51f6b9d7b7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_metric/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathMetricMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-metric + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-metric + """ + + def __init__(self): + super().__init__(PathMetric) + + def __get__(self, instance, owner=None) -> ( + 'PathMetricMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathMetric']: + pass + + def __iter__(self, key) -> Iterator['PathMetric']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathMetric': + return super()[key] + + def __enter__(self) -> ( + 'PathMetricMeta.yang_list_descriptor'): + pass + + +class PathMetric( + YANGListItem, + metaclass=PathMetricMeta): + """ + YANG list item handler. + + YANG name: path-metric + """ + + _yang_name: Final[str] = 'path-metric' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'metric-type', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'metric-type': ( + metric_type := YANGLeafMember( + 'metric-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'accumulative-value': ( + accumulative_value := YANGLeafMember( + 'accumulative-value', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathMetric': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2af8eb3f47d7b0ceb2d21f9f5b1ee44b432ab35f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-route-objects + """ + from .path_route_object import PathRouteObject + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-route-objects + """ + + def __init__(self): + super().__init__(PathRouteObjects) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathRouteObjects': + pass + + def __enter__(self) -> 'PathRouteObjects': + pass + + +class PathRouteObjects( + YANGContainer, + metaclass=PathRouteObjectsMeta): + """ + YANG container handler. + + YANG name: path-route-objects + """ + + _yang_name: Final[str] = 'path-route-objects' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-route-object': ( + path_route_object := ( # YANGListMember( + PathRouteObjectsMeta. + PathRouteObject. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObjects': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..74b9e21c769902d7a2bb1f362d2e95cbf5d862cd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathRouteObjectMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-route-object + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-route-object + """ + + def __init__(self): + super().__init__(PathRouteObject) + + def __get__(self, instance, owner=None) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathRouteObject']: + pass + + def __iter__(self, key) -> Iterator['PathRouteObject']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathRouteObject': + return super()[key] + + def __enter__(self) -> ( + 'PathRouteObjectMeta.yang_list_descriptor'): + pass + + +class PathRouteObject( + YANGListItem, + metaclass=PathRouteObjectMeta): + """ + YANG list item handler. + + YANG name: path-route-object + """ + + _yang_name: Final[str] = 'path-route-object' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathRouteObject': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathRouteObjectMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathRouteObjectMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ba147c0c9510241b8cc6f8aa2235042dd634f850 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_node_hop import NumberedNodeHop + from .as_number import AsNumber + from .numbered_link_hop import NumberedLinkHop + from .label import Label + from .unnumbered_link_hop import UnnumberedLinkHop + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1cb78075b80ccd8887818376324a016daf17b67c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e568286bdabfa9cd970ff66b3e9b6a807b0f31f3 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_route_objects/path_route_object/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_lists/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_lists/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5e807a0b29d665deaaed7620fee6b2b7c697fbb6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_lists/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-lists + """ + from .path_srlgs_list import PathSrlgsList + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-lists + """ + + def __init__(self): + super().__init__(PathSrlgsLists) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsLists': + pass + + def __enter__(self) -> 'PathSrlgsLists': + pass + + +class PathSrlgsLists( + YANGContainer, + metaclass=PathSrlgsListsMeta): + """ + YANG container handler. + + YANG name: path-srlgs-lists + """ + + _yang_name: Final[str] = 'path-srlgs-lists' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-list': ( + path_srlgs_list := ( # YANGListMember( + PathSrlgsListsMeta. + PathSrlgsList. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsLists': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..631911d141fd6e870942bd77f7ad80c33e221091 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_lists/path_srlgs_list/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsListMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-list + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-list + """ + + def __init__(self): + super().__init__(PathSrlgsList) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsList']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsList']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsList': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsListMeta.yang_list_descriptor'): + pass + + +class PathSrlgsList( + YANGListItem, + metaclass=PathSrlgsListMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-list + """ + + _yang_name: Final[str] = 'path-srlgs-list' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsList': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_names/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_names/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..54d85c0e52070f3cffb5a27ea963d0923bdcc379 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_names/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNamesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: path-srlgs-names + """ + from .path_srlgs_name import PathSrlgsName + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: path-srlgs-names + """ + + def __init__(self): + super().__init__(PathSrlgsNames) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNamesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PathSrlgsNames': + pass + + def __enter__(self) -> 'PathSrlgsNames': + pass + + +class PathSrlgsNames( + YANGContainer, + metaclass=PathSrlgsNamesMeta): + """ + YANG container handler. + + YANG name: path-srlgs-names + """ + + _yang_name: Final[str] = 'path-srlgs-names' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-srlgs-name': ( + path_srlgs_name := ( # YANGListMember( + PathSrlgsNamesMeta. + PathSrlgsName. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsNames': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_names/path_srlgs_name/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_names/path_srlgs_name/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d9b66f1860f862ec66429b96c9f73d88815ecfd6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/path_properties/path_srlgs_names/path_srlgs_name/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathSrlgsNameMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-srlgs-name + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-srlgs-name + """ + + def __init__(self): + super().__init__(PathSrlgsName) + + def __get__(self, instance, owner=None) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathSrlgsName']: + pass + + def __iter__(self, key) -> Iterator['PathSrlgsName']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathSrlgsName': + return super()[key] + + def __enter__(self) -> ( + 'PathSrlgsNameMeta.yang_list_descriptor'): + pass + + +class PathSrlgsName( + YANGListItem, + metaclass=PathSrlgsNameMeta): + """ + YANG list item handler. + + YANG name: path-srlgs-name + """ + + _yang_name: Final[str] = 'path-srlgs-name' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'usage', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'usage': ( + usage := YANGLeafMember( + 'usage', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathSrlgsName': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9ef388cd63aa7c8947fc3391bad703bb01f3d827 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/__init__.py @@ -0,0 +1,119 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay + """ + from .primary_path import PrimaryPath + from .tunnel_termination_points import TunnelTerminationPoints + from .tunnels import Tunnels + from .backup_path import BackupPath + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay + """ + + def __init__(self): + super().__init__(Underlay) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Underlay': + pass + + def __enter__(self) -> 'Underlay': + pass + + +class Underlay( + YANGContainer, + metaclass=UnderlayMeta): + """ + YANG container handler. + + YANG name: underlay + """ + + _yang_name: Final[str] = 'underlay' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'enabled': ( + enabled := YANGLeafMember( + 'enabled', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'protection-type': ( + protection_type := YANGLeafMember( + 'protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'primary-path': ( + primary_path := ( # YANGContainerMember( + UnderlayMeta. + PrimaryPath. + yang_container_descriptor())), + + 'tunnel-termination-points': ( + tunnel_termination_points := ( # YANGContainerMember( + UnderlayMeta. + TunnelTerminationPoints. + yang_container_descriptor())), + + 'tunnels': ( + tunnels := ( # YANGContainerMember( + UnderlayMeta. + Tunnels. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'backup-path': ( + backup_path := ( # YANGListMember( + UnderlayMeta. + BackupPath. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Underlay': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6b6e1ff5cb9da5f8c265df0f8c0854de089ff9ef --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/__init__.py @@ -0,0 +1,109 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BackupPathMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: backup-path + """ + from .path_element import PathElement + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: backup-path + """ + + def __init__(self): + super().__init__(BackupPath) + + def __get__(self, instance, owner=None) -> ( + 'BackupPathMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['BackupPath']: + pass + + def __iter__(self, key) -> Iterator['BackupPath']: + return super().__iter__() + + def __getitem__(self, key) -> 'BackupPath': + return super()[key] + + def __enter__(self) -> ( + 'BackupPathMeta.yang_list_descriptor'): + pass + + +class BackupPath( + YANGListItem, + metaclass=BackupPathMeta): + """ + YANG list item handler. + + YANG name: backup-path + """ + + _yang_name: Final[str] = 'backup-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + BackupPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'BackupPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..756916fe5305db0152f03d2c6c3aabec84ab6e89 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .label import Label + from .numbered_link_hop import NumberedLinkHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + from .numbered_node_hop import NumberedNodeHop + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1abedb4d3f8145943387f3e66e3e17fed741dcdc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8b97fc02b90568c1b4e8df5f758ab24f6bcb5be9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3a6876e61b9d99b8ed5b00bc13f60857e8fb3d76 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..34a2a729ce6d45e11174065699c428a7ac677a8b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PrimaryPathMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: primary-path + """ + from .path_element import PathElement + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: primary-path + """ + + def __init__(self): + super().__init__(PrimaryPath) + + def __get__(self, instance, owner=None) -> ( + 'PrimaryPathMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PrimaryPath': + pass + + def __enter__(self) -> 'PrimaryPath': + pass + + +class PrimaryPath( + YANGContainer, + metaclass=PrimaryPathMeta): + """ + YANG container handler. + + YANG name: primary-path + """ + + _yang_name: Final[str] = 'primary-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + PrimaryPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PrimaryPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..dcd3c6917ac3e0b72b371917edbce5bc14d39c40 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .label import Label + from .numbered_node_hop import NumberedNodeHop + from .as_number import AsNumber + from .numbered_link_hop import NumberedLinkHop + from .unnumbered_link_hop import UnnumberedLinkHop + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..64a8ec6d5e2fd4a77c59c13b3e37cacb001c91fe --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5baa996de0fff24876e40ec73f87a7a90da1f2ea --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/tunnel_termination_points/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/tunnel_termination_points/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8ae8cc268f3c4fc331cd1e1018be41d113da9183 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/tunnel_termination_points/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelTerminationPointsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnel-termination-points + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnel-termination-points + """ + + def __init__(self): + super().__init__(TunnelTerminationPoints) + + def __get__(self, instance, owner=None) -> ( + 'TunnelTerminationPointsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TunnelTerminationPoints': + pass + + def __enter__(self) -> 'TunnelTerminationPoints': + pass + + +class TunnelTerminationPoints( + YANGContainer, + metaclass=TunnelTerminationPointsMeta): + """ + YANG container handler. + + YANG name: tunnel-termination-points + """ + + _yang_name: Final[str] = 'tunnel-termination-points' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'source': ( + source := YANGLeafMember( + 'source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'destination': ( + destination := YANGLeafMember( + 'destination', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TunnelTerminationPoints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/tunnels/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/tunnels/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..303858f3e0c28faecf9696d2fbf403d5510cced8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/tunnels/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnels + """ + from .tunnel import Tunnel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnels + """ + + def __init__(self): + super().__init__(Tunnels) + + def __get__(self, instance, owner=None) -> ( + 'TunnelsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tunnels': + pass + + def __enter__(self) -> 'Tunnels': + pass + + +class Tunnels( + YANGContainer, + metaclass=TunnelsMeta): + """ + YANG container handler. + + YANG name: tunnels + """ + + _yang_name: Final[str] = 'tunnels' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tunnel': ( + tunnel := ( # YANGListMember( + TunnelsMeta. + Tunnel. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnels': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/tunnels/tunnel/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/tunnels/tunnel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f854dfd329ce016317b7b9743ace874769f03094 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/local_link_connectivities/underlay/tunnels/tunnel/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tunnel + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tunnel + """ + + def __init__(self): + super().__init__(Tunnel) + + def __get__(self, instance, owner=None) -> ( + 'TunnelMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tunnel']: + pass + + def __iter__(self, key) -> Iterator['Tunnel']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tunnel': + return super()[key] + + def __enter__(self) -> ( + 'TunnelMeta.yang_list_descriptor'): + pass + + +class Tunnel( + YANGListItem, + metaclass=TunnelMeta): + """ + YANG list item handler. + + YANG name: tunnel + """ + + _yang_name: Final[str] = 'tunnel' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tunnel-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'tunnel-name': ( + tunnel_name := YANGLeafMember( + 'tunnel-name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnel': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/statistics/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/statistics/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9ed869cac9cbe0a847a4fd06e39f4e8cb0944cfb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/statistics/__init__.py @@ -0,0 +1,99 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class StatisticsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: statistics + """ + from .tunnel_termination_point import TunnelTerminationPoint + from .local_link_connectivity import LocalLinkConnectivity + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: statistics + """ + + def __init__(self): + super().__init__(Statistics) + + def __get__(self, instance, owner=None) -> ( + 'StatisticsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Statistics': + pass + + def __enter__(self) -> 'Statistics': + pass + + +class Statistics( + YANGContainer, + metaclass=StatisticsMeta): + """ + YANG container handler. + + YANG name: statistics + """ + + _yang_name: Final[str] = 'statistics' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'discontinuity-time': ( + discontinuity_time := YANGLeafMember( + 'discontinuity-time', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'tunnel-termination-point': ( + tunnel_termination_point := ( # YANGContainerMember( + StatisticsMeta. + TunnelTerminationPoint. + yang_container_descriptor())), + + 'local-link-connectivity': ( + local_link_connectivity := ( # YANGContainerMember( + StatisticsMeta. + LocalLinkConnectivity. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Statistics': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/statistics/local_link_connectivity/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/statistics/local_link_connectivity/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..968aa5f224d812d13c53912ca6346f0e872afa9d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/statistics/local_link_connectivity/__init__.py @@ -0,0 +1,109 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LocalLinkConnectivityMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: local-link-connectivity + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: local-link-connectivity + """ + + def __init__(self): + super().__init__(LocalLinkConnectivity) + + def __get__(self, instance, owner=None) -> ( + 'LocalLinkConnectivityMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LocalLinkConnectivity': + pass + + def __enter__(self) -> 'LocalLinkConnectivity': + pass + + +class LocalLinkConnectivity( + YANGContainer, + metaclass=LocalLinkConnectivityMeta): + """ + YANG container handler. + + YANG name: local-link-connectivity + """ + + _yang_name: Final[str] = 'local-link-connectivity' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'enables': ( + enables := YANGLeafMember( + 'enables', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'creates': ( + creates := YANGLeafMember( + 'creates', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'deletes': ( + deletes := YANGLeafMember( + 'deletes', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'modifies': ( + modifies := YANGLeafMember( + 'modifies', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'disables': ( + disables := YANGLeafMember( + 'disables', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LocalLinkConnectivity': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/statistics/tunnel_termination_point/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/statistics/tunnel_termination_point/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0226e0183e765f0c6bfc59a10e95220a32c88eb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/statistics/tunnel_termination_point/__init__.py @@ -0,0 +1,133 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelTerminationPointMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnel-termination-point + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnel-termination-point + """ + + def __init__(self): + super().__init__(TunnelTerminationPoint) + + def __get__(self, instance, owner=None) -> ( + 'TunnelTerminationPointMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TunnelTerminationPoint': + pass + + def __enter__(self) -> 'TunnelTerminationPoint': + pass + + +class TunnelTerminationPoint( + YANGContainer, + metaclass=TunnelTerminationPointMeta): + """ + YANG container handler. + + YANG name: tunnel-termination-point + """ + + _yang_name: Final[str] = 'tunnel-termination-point' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'maintenance-sets': ( + maintenance_sets := YANGLeafMember( + 'maintenance-sets', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'downs': ( + downs := YANGLeafMember( + 'downs', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'modifies': ( + modifies := YANGLeafMember( + 'modifies', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'disables': ( + disables := YANGLeafMember( + 'disables', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'in-service-sets': ( + in_service_sets := YANGLeafMember( + 'in-service-sets', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'enables': ( + enables := YANGLeafMember( + 'enables', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'maintenance-clears': ( + maintenance_clears := YANGLeafMember( + 'maintenance-clears', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'ups': ( + ups := YANGLeafMember( + 'ups', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'in-service-clears': ( + in_service_clears := YANGLeafMember( + 'in-service-clears', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TunnelTerminationPoint': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/supporting_tunnel_termination_point/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/supporting_tunnel_termination_point/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6c49df48431602d92607be89318349d2e837536e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/te/tunnel_termination_point/supporting_tunnel_termination_point/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SupportingTunnelTerminationPointMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: supporting-tunnel-termination-point + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: supporting-tunnel-termination-point + """ + + def __init__(self): + super().__init__(SupportingTunnelTerminationPoint) + + def __get__(self, instance, owner=None) -> ( + 'SupportingTunnelTerminationPointMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['SupportingTunnelTerminationPoint']: + pass + + def __iter__(self, key) -> Iterator['SupportingTunnelTerminationPoint']: + return super().__iter__() + + def __getitem__(self, key) -> 'SupportingTunnelTerminationPoint': + return super()[key] + + def __enter__(self) -> ( + 'SupportingTunnelTerminationPointMeta.yang_list_descriptor'): + pass + + +class SupportingTunnelTerminationPoint( + YANGListItem, + metaclass=SupportingTunnelTerminationPointMeta): + """ + YANG list item handler. + + YANG name: supporting-tunnel-termination-point + """ + + _yang_name: Final[str] = 'supporting-tunnel-termination-point' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'node-ref', + 'tunnel-tp-ref', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'tunnel-tp-ref': ( + tunnel_tp_ref := YANGLeafMember( + 'tunnel-tp-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-ref': ( + node_ref := YANGLeafMember( + 'node-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SupportingTunnelTerminationPoint': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c57b1997c1a86a82962fe2fa49041f529d8c1e0b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/__init__.py @@ -0,0 +1,116 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TerminationPointMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: termination-point + """ + from .te import Te + from .supporting_termination_point import SupportingTerminationPoint + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: termination-point + """ + + def __init__(self): + super().__init__(TerminationPoint) + + def __get__(self, instance, owner=None) -> ( + 'TerminationPointMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['TerminationPoint']: + pass + + def __iter__(self, key) -> Iterator['TerminationPoint']: + return super().__iter__() + + def __getitem__(self, key) -> 'TerminationPoint': + return super()[key] + + def __enter__(self) -> ( + 'TerminationPointMeta.yang_list_descriptor'): + pass + + +class TerminationPoint( + YANGListItem, + metaclass=TerminationPointMeta): + """ + YANG list item handler. + + YANG name: termination-point + """ + + _yang_name: Final[str] = 'termination-point' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-topology' + _yang_module_name: Final[str] = 'ietf-network-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tp-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'te-tp-id': ( + te_tp_id := YANGLeafMember( + 'te-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'tp-id': ( + tp_id := YANGLeafMember( + 'tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-network-topology', + 'ietf-network-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te': ( + te := ( # YANGContainerMember( + TerminationPointMeta. + Te. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'supporting-termination-point': ( + supporting_termination_point := ( # YANGListMember( + TerminationPointMeta. + SupportingTerminationPoint. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TerminationPoint': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/supporting_termination_point/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/supporting_termination_point/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..677a83f1ad4e37460d2b705a8aae82f716d19ced --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/supporting_termination_point/__init__.py @@ -0,0 +1,110 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SupportingTerminationPointMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: supporting-termination-point + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: supporting-termination-point + """ + + def __init__(self): + super().__init__(SupportingTerminationPoint) + + def __get__(self, instance, owner=None) -> ( + 'SupportingTerminationPointMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['SupportingTerminationPoint']: + pass + + def __iter__(self, key) -> Iterator['SupportingTerminationPoint']: + return super().__iter__() + + def __getitem__(self, key) -> 'SupportingTerminationPoint': + return super()[key] + + def __enter__(self) -> ( + 'SupportingTerminationPointMeta.yang_list_descriptor'): + pass + + +class SupportingTerminationPoint( + YANGListItem, + metaclass=SupportingTerminationPointMeta): + """ + YANG list item handler. + + YANG name: supporting-termination-point + """ + + _yang_name: Final[str] = 'supporting-termination-point' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network-topology' + _yang_module_name: Final[str] = 'ietf-network-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'network-ref', + 'node-ref', + 'tp-ref', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-ref': ( + node_ref := YANGLeafMember( + 'node-ref', + 'urn:ietf:params:xml:ns:yang:ietf-network-topology', + 'ietf-network-topology')), + + 'tp-ref': ( + tp_ref := YANGLeafMember( + 'tp-ref', + 'urn:ietf:params:xml:ns:yang:ietf-network-topology', + 'ietf-network-topology')), + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-network-topology', + 'ietf-network-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SupportingTerminationPoint': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..01c6bcdf0dcc0a0e9c3adb4b0c4580182a030510 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/__init__.py @@ -0,0 +1,117 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te + """ + from .geolocation import Geolocation + from .interface_switching_capability import InterfaceSwitchingCapability + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te + """ + + def __init__(self): + super().__init__(Te) + + def __get__(self, instance, owner=None) -> ( + 'TeMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Te': + pass + + def __enter__(self) -> 'Te': + pass + + +class Te( + YANGContainer, + metaclass=TeMeta): + """ + YANG container handler. + + YANG name: te + """ + + _yang_name: Final[str] = 'te' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'admin-status': ( + admin_status := YANGLeafMember( + 'admin-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'inter-domain-plug-id': ( + inter_domain_plug_id := YANGLeafMember( + 'inter-domain-plug-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'oper-status': ( + oper_status := YANGLeafMember( + 'oper-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'geolocation': ( + geolocation := ( # YANGContainerMember( + TeMeta. + Geolocation. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'interface-switching-capability': ( + interface_switching_capability := ( # YANGListMember( + TeMeta. + InterfaceSwitchingCapability. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Te': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/geolocation/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/geolocation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e58eb1516669a36eac9abd5451d7335da8de62a4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/geolocation/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GeolocationMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: geolocation + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: geolocation + """ + + def __init__(self): + super().__init__(Geolocation) + + def __get__(self, instance, owner=None) -> ( + 'GeolocationMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Geolocation': + pass + + def __enter__(self) -> 'Geolocation': + pass + + +class Geolocation( + YANGContainer, + metaclass=GeolocationMeta): + """ + YANG container handler. + + YANG name: geolocation + """ + + _yang_name: Final[str] = 'geolocation' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'latitude': ( + latitude := YANGLeafMember( + 'latitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'longitude': ( + longitude := YANGLeafMember( + 'longitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'altitude': ( + altitude := YANGLeafMember( + 'altitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Geolocation': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aed5f69dcca9f3ba106cbda0db555f0efa7fecd1 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/__init__.py @@ -0,0 +1,110 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class InterfaceSwitchingCapabilityMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: interface-switching-capability + """ + from .max_lsp_bandwidth import MaxLspBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: interface-switching-capability + """ + + def __init__(self): + super().__init__(InterfaceSwitchingCapability) + + def __get__(self, instance, owner=None) -> ( + 'InterfaceSwitchingCapabilityMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['InterfaceSwitchingCapability']: + pass + + def __iter__(self, key) -> Iterator['InterfaceSwitchingCapability']: + return super().__iter__() + + def __getitem__(self, key) -> 'InterfaceSwitchingCapability': + return super()[key] + + def __enter__(self) -> ( + 'InterfaceSwitchingCapabilityMeta.yang_list_descriptor'): + pass + + +class InterfaceSwitchingCapability( + YANGListItem, + metaclass=InterfaceSwitchingCapabilityMeta): + """ + YANG list item handler. + + YANG name: interface-switching-capability + """ + + _yang_name: Final[str] = 'interface-switching-capability' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'switching-capability', + 'encoding', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'encoding': ( + encoding := YANGLeafMember( + 'encoding', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'switching-capability': ( + switching_capability := YANGLeafMember( + 'switching-capability', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'max-lsp-bandwidth': ( + max_lsp_bandwidth := ( # YANGListMember( + InterfaceSwitchingCapabilityMeta. + MaxLspBandwidth. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'InterfaceSwitchingCapability': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ddad298bbc0cc7c626bd869965fe6da4630b6fb5 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MaxLspBandwidthMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: max-lsp-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: max-lsp-bandwidth + """ + + def __init__(self): + super().__init__(MaxLspBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'MaxLspBandwidthMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['MaxLspBandwidth']: + pass + + def __iter__(self, key) -> Iterator['MaxLspBandwidth']: + return super().__iter__() + + def __getitem__(self, key) -> 'MaxLspBandwidth': + return super()[key] + + def __enter__(self) -> ( + 'MaxLspBandwidthMeta.yang_list_descriptor'): + pass + + +class MaxLspBandwidth( + YANGListItem, + metaclass=MaxLspBandwidthMeta): + """ + YANG list item handler. + + YANG name: max-lsp-bandwidth + """ + + _yang_name: Final[str] = 'max-lsp-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'priority', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'priority': ( + priority := YANGLeafMember( + 'priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + MaxLspBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MaxLspBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/node/termination_point/te/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/supporting_network/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/supporting_network/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1edaacf9b3aac3691d69f548e6e01772d428b4c6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/supporting_network/__init__.py @@ -0,0 +1,96 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class SupportingNetworkMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: supporting-network + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: supporting-network + """ + + def __init__(self): + super().__init__(SupportingNetwork) + + def __get__(self, instance, owner=None) -> ( + 'SupportingNetworkMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['SupportingNetwork']: + pass + + def __iter__(self, key) -> Iterator['SupportingNetwork']: + return super().__iter__() + + def __getitem__(self, key) -> 'SupportingNetwork': + return super()[key] + + def __enter__(self) -> ( + 'SupportingNetworkMeta.yang_list_descriptor'): + pass + + +class SupportingNetwork( + YANGListItem, + metaclass=SupportingNetworkMeta): + """ + YANG list item handler. + + YANG name: supporting-network + """ + + _yang_name: Final[str] = 'supporting-network' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-network' + _yang_module_name: Final[str] = 'ietf-network' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'network-ref', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-network', + 'ietf-network')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'SupportingNetwork': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..748195d4bd7b81c2ed3d20720cab2c5bff4750aa --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te/__init__.py @@ -0,0 +1,111 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te + """ + from .geolocation import Geolocation + from .nsrlg import Nsrlg + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te + """ + + def __init__(self): + super().__init__(Te) + + def __get__(self, instance, owner=None) -> ( + 'TeMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Te': + pass + + def __enter__(self) -> 'Te': + pass + + +class Te( + YANGContainer, + metaclass=TeMeta): + """ + YANG container handler. + + YANG name: te + """ + + _yang_name: Final[str] = 'te' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'preference': ( + preference := YANGLeafMember( + 'preference', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'optimization-criterion': ( + optimization_criterion := YANGLeafMember( + 'optimization-criterion', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'geolocation': ( + geolocation := ( # YANGContainerMember( + TeMeta. + Geolocation. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'nsrlg': ( + nsrlg := ( # YANGListMember( + TeMeta. + Nsrlg. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Te': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te/geolocation/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te/geolocation/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5a631c3553d9ab5ce7b22b799dbf338a0f87fa43 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te/geolocation/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GeolocationMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: geolocation + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: geolocation + """ + + def __init__(self): + super().__init__(Geolocation) + + def __get__(self, instance, owner=None) -> ( + 'GeolocationMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Geolocation': + pass + + def __enter__(self) -> 'Geolocation': + pass + + +class Geolocation( + YANGContainer, + metaclass=GeolocationMeta): + """ + YANG container handler. + + YANG name: geolocation + """ + + _yang_name: Final[str] = 'geolocation' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'latitude': ( + latitude := YANGLeafMember( + 'latitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'altitude': ( + altitude := YANGLeafMember( + 'altitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'longitude': ( + longitude := YANGLeafMember( + 'longitude', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Geolocation': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te/nsrlg/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te/nsrlg/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ed5c7ab09b9180c21eb845684ade6a69b7ca0705 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te/nsrlg/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NsrlgMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: nsrlg + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: nsrlg + """ + + def __init__(self): + super().__init__(Nsrlg) + + def __get__(self, instance, owner=None) -> ( + 'NsrlgMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Nsrlg']: + pass + + def __iter__(self, key) -> Iterator['Nsrlg']: + return super().__iter__() + + def __getitem__(self, key) -> 'Nsrlg': + return super()[key] + + def __enter__(self) -> ( + 'NsrlgMeta.yang_list_descriptor'): + pass + + +class Nsrlg( + YANGListItem, + metaclass=NsrlgMeta): + """ + YANG list item handler. + + YANG name: nsrlg + """ + + _yang_name: Final[str] = 'nsrlg' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'id': ( + id := YANGLeafMember( + 'id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'disjointness': ( + disjointness := YANGLeafMember( + 'disjointness', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Nsrlg': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te_topology_identifier/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te_topology_identifier/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7960995015a5d11e0610babc72827436a32087c1 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/network/te_topology_identifier/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeTopologyIdentifierMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-topology-identifier + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-topology-identifier + """ + + def __init__(self): + super().__init__(TeTopologyIdentifier) + + def __get__(self, instance, owner=None) -> ( + 'TeTopologyIdentifierMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeTopologyIdentifier': + pass + + def __enter__(self) -> 'TeTopologyIdentifier': + pass + + +class TeTopologyIdentifier( + YANGContainer, + metaclass=TeTopologyIdentifierMeta): + """ + YANG container handler. + + YANG name: te-topology-identifier + """ + + _yang_name: Final[str] = 'te-topology-identifier' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'topology-id': ( + topology_id := YANGLeafMember( + 'topology-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'provider-id': ( + provider_id := YANGLeafMember( + 'provider-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'client-id': ( + client_id := YANGLeafMember( + 'client-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeTopologyIdentifier': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e44025b207547eea5e7bd79b657543db9c3a4deb --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te + """ + from .templates import Templates + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te + """ + + def __init__(self): + super().__init__(Te) + + def __get__(self, instance, owner=None) -> ( + 'TeMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Te': + pass + + def __enter__(self) -> 'Te': + pass + + +class Te( + YANGContainer, + metaclass=TeMeta): + """ + YANG container handler. + + YANG name: te + """ + + _yang_name: Final[str] = 'te' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'templates': ( + templates := ( # YANGContainerMember( + TeMeta. + Templates. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Te': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7445085d6958e61bbe27aa9366276cfb2d0f2fa4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/__init__.py @@ -0,0 +1,93 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TemplatesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: templates + """ + from .link_template import LinkTemplate + from .node_template import NodeTemplate + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: templates + """ + + def __init__(self): + super().__init__(Templates) + + def __get__(self, instance, owner=None) -> ( + 'TemplatesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Templates': + pass + + def __enter__(self) -> 'Templates': + pass + + +class Templates( + YANGContainer, + metaclass=TemplatesMeta): + """ + YANG container handler. + + YANG name: templates + """ + + _yang_name: Final[str] = 'templates' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'link-template': ( + link_template := ( # YANGListMember( + TemplatesMeta. + LinkTemplate. + yang_list_descriptor())), + + 'node-template': ( + node_template := ( # YANGListMember( + TemplatesMeta. + NodeTemplate. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Templates': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6436895020aa9f268a9cf4b4959e7b3782ab8fdd --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/__init__.py @@ -0,0 +1,115 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LinkTemplateMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: link-template + """ + from .te_link_attributes import TeLinkAttributes + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: link-template + """ + + def __init__(self): + super().__init__(LinkTemplate) + + def __get__(self, instance, owner=None) -> ( + 'LinkTemplateMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LinkTemplate']: + pass + + def __iter__(self, key) -> Iterator['LinkTemplate']: + return super().__iter__() + + def __getitem__(self, key) -> 'LinkTemplate': + return super()[key] + + def __enter__(self) -> ( + 'LinkTemplateMeta.yang_list_descriptor'): + pass + + +class LinkTemplate( + YANGListItem, + metaclass=LinkTemplateMeta): + """ + YANG list item handler. + + YANG name: link-template + """ + + _yang_name: Final[str] = 'link-template' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'reference-change-policy': ( + reference_change_policy := YANGLeafMember( + 'reference-change-policy', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'priority': ( + priority := YANGLeafMember( + 'priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-link-attributes': ( + te_link_attributes := ( # YANGContainerMember( + LinkTemplateMeta. + TeLinkAttributes. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LinkTemplate': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8165170f1f32e48c8d9e9a8bf33effd915d56ea8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/__init__.py @@ -0,0 +1,202 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLinkAttributesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-link-attributes + """ + from .external_domain import ExternalDomain + from .max_link_bandwidth import MaxLinkBandwidth + from .te_nsrlgs import TeNsrlgs + from .max_resv_link_bandwidth import MaxResvLinkBandwidth + from .label_restrictions import LabelRestrictions + from .underlay import Underlay + from .te_srlgs import TeSrlgs + from .interface_switching_capability import InterfaceSwitchingCapability + from .unreserved_bandwidth import UnreservedBandwidth + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-link-attributes + """ + + def __init__(self): + super().__init__(TeLinkAttributes) + + def __get__(self, instance, owner=None) -> ( + 'TeLinkAttributesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLinkAttributes': + pass + + def __enter__(self) -> 'TeLinkAttributes': + pass + + +class TeLinkAttributes( + YANGContainer, + metaclass=TeLinkAttributesMeta): + """ + YANG container handler. + + YANG name: te-link-attributes + """ + + _yang_name: Final[str] = 'te-link-attributes' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'te-delay-metric': ( + te_delay_metric := YANGLeafMember( + 'te-delay-metric', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'admin-status': ( + admin_status := YANGLeafMember( + 'admin-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'administrative-group': ( + administrative_group := YANGLeafMember( + 'administrative-group', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-index': ( + link_index := YANGLeafMember( + 'link-index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'access-type': ( + access_type := YANGLeafMember( + 'access-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'te-igp-metric': ( + te_igp_metric := YANGLeafMember( + 'te-igp-metric', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'te-default-metric': ( + te_default_metric := YANGLeafMember( + 'te-default-metric', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'is-abstract': ( + is_abstract := YANGLeafMember( + 'is-abstract', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-protection-type': ( + link_protection_type := YANGLeafMember( + 'link-protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'external-domain': ( + external_domain := ( # YANGContainerMember( + TeLinkAttributesMeta. + ExternalDomain. + yang_container_descriptor())), + + 'max-link-bandwidth': ( + max_link_bandwidth := ( # YANGContainerMember( + TeLinkAttributesMeta. + MaxLinkBandwidth. + yang_container_descriptor())), + + 'te-nsrlgs': ( + te_nsrlgs := ( # YANGContainerMember( + TeLinkAttributesMeta. + TeNsrlgs. + yang_container_descriptor())), + + 'max-resv-link-bandwidth': ( + max_resv_link_bandwidth := ( # YANGContainerMember( + TeLinkAttributesMeta. + MaxResvLinkBandwidth. + yang_container_descriptor())), + + 'label-restrictions': ( + label_restrictions := ( # YANGContainerMember( + TeLinkAttributesMeta. + LabelRestrictions. + yang_container_descriptor())), + + 'underlay': ( + underlay := ( # YANGContainerMember( + TeLinkAttributesMeta. + Underlay. + yang_container_descriptor())), + + 'te-srlgs': ( + te_srlgs := ( # YANGContainerMember( + TeLinkAttributesMeta. + TeSrlgs. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'interface-switching-capability': ( + interface_switching_capability := ( # YANGListMember( + TeLinkAttributesMeta. + InterfaceSwitchingCapability. + yang_list_descriptor())), + + 'unreserved-bandwidth': ( + unreserved_bandwidth := ( # YANGListMember( + TeLinkAttributesMeta. + UnreservedBandwidth. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLinkAttributes': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/external_domain/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/external_domain/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..30e28c4c7b69dff7823e0a7aa87672840b5f317b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/external_domain/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class ExternalDomainMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: external-domain + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: external-domain + """ + + def __init__(self): + super().__init__(ExternalDomain) + + def __get__(self, instance, owner=None) -> ( + 'ExternalDomainMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'ExternalDomain': + pass + + def __enter__(self) -> 'ExternalDomain': + pass + + +class ExternalDomain( + YANGContainer, + metaclass=ExternalDomainMeta): + """ + YANG container handler. + + YANG name: external-domain + """ + + _yang_name: Final[str] = 'external-domain' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'remote-te-link-tp-id': ( + remote_te_link_tp_id := YANGLeafMember( + 'remote-te-link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'remote-te-node-id': ( + remote_te_node_id := YANGLeafMember( + 'remote-te-node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'ExternalDomain': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aed5f69dcca9f3ba106cbda0db555f0efa7fecd1 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/__init__.py @@ -0,0 +1,110 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class InterfaceSwitchingCapabilityMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: interface-switching-capability + """ + from .max_lsp_bandwidth import MaxLspBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: interface-switching-capability + """ + + def __init__(self): + super().__init__(InterfaceSwitchingCapability) + + def __get__(self, instance, owner=None) -> ( + 'InterfaceSwitchingCapabilityMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['InterfaceSwitchingCapability']: + pass + + def __iter__(self, key) -> Iterator['InterfaceSwitchingCapability']: + return super().__iter__() + + def __getitem__(self, key) -> 'InterfaceSwitchingCapability': + return super()[key] + + def __enter__(self) -> ( + 'InterfaceSwitchingCapabilityMeta.yang_list_descriptor'): + pass + + +class InterfaceSwitchingCapability( + YANGListItem, + metaclass=InterfaceSwitchingCapabilityMeta): + """ + YANG list item handler. + + YANG name: interface-switching-capability + """ + + _yang_name: Final[str] = 'interface-switching-capability' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'switching-capability', + 'encoding', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'encoding': ( + encoding := YANGLeafMember( + 'encoding', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'switching-capability': ( + switching_capability := YANGLeafMember( + 'switching-capability', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'max-lsp-bandwidth': ( + max_lsp_bandwidth := ( # YANGListMember( + InterfaceSwitchingCapabilityMeta. + MaxLspBandwidth. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'InterfaceSwitchingCapability': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ddad298bbc0cc7c626bd869965fe6da4630b6fb5 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MaxLspBandwidthMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: max-lsp-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: max-lsp-bandwidth + """ + + def __init__(self): + super().__init__(MaxLspBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'MaxLspBandwidthMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['MaxLspBandwidth']: + pass + + def __iter__(self, key) -> Iterator['MaxLspBandwidth']: + return super().__iter__() + + def __getitem__(self, key) -> 'MaxLspBandwidth': + return super()[key] + + def __enter__(self) -> ( + 'MaxLspBandwidthMeta.yang_list_descriptor'): + pass + + +class MaxLspBandwidth( + YANGListItem, + metaclass=MaxLspBandwidthMeta): + """ + YANG list item handler. + + YANG name: max-lsp-bandwidth + """ + + _yang_name: Final[str] = 'max-lsp-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'priority', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'priority': ( + priority := YANGLeafMember( + 'priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + MaxLspBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MaxLspBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/interface_switching_capability/max_lsp_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..29f30ca794c567238bb34de6d5de219f72b68cca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-restrictions + """ + from .label_restriction import LabelRestriction + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-restrictions + """ + + def __init__(self): + super().__init__(LabelRestrictions) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelRestrictions': + pass + + def __enter__(self) -> 'LabelRestrictions': + pass + + +class LabelRestrictions( + YANGContainer, + metaclass=LabelRestrictionsMeta): + """ + YANG container handler. + + YANG name: label-restrictions + """ + + _yang_name: Final[str] = 'label-restrictions' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'label-restriction': ( + label_restriction := ( # YANGListMember( + LabelRestrictionsMeta. + LabelRestriction. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestrictions': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..59861169cdfff61daccfdded5e79caf46694f7f1 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/__init__.py @@ -0,0 +1,129 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelRestrictionMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: label-restriction + """ + from .label_end import LabelEnd + from .label_start import LabelStart + from .label_step import LabelStep + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: label-restriction + """ + + def __init__(self): + super().__init__(LabelRestriction) + + def __get__(self, instance, owner=None) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['LabelRestriction']: + pass + + def __iter__(self, key) -> Iterator['LabelRestriction']: + return super().__iter__() + + def __getitem__(self, key) -> 'LabelRestriction': + return super()[key] + + def __enter__(self) -> ( + 'LabelRestrictionMeta.yang_list_descriptor'): + pass + + +class LabelRestriction( + YANGListItem, + metaclass=LabelRestrictionMeta): + """ + YANG list item handler. + + YANG name: label-restriction + """ + + _yang_name: Final[str] = 'label-restriction' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'range-bitmap': ( + range_bitmap := YANGLeafMember( + 'range-bitmap', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'restriction': ( + restriction := YANGLeafMember( + 'restriction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-end': ( + label_end := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelEnd. + yang_container_descriptor())), + + 'label-start': ( + label_start := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStart. + yang_container_descriptor())), + + 'label-step': ( + label_step := ( # YANGContainerMember( + LabelRestrictionMeta. + LabelStep. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelRestriction': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2ad525773e032b7b224f5b661e728ffe8950e98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelEndMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-end + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-end + """ + + def __init__(self): + super().__init__(LabelEnd) + + def __get__(self, instance, owner=None) -> ( + 'LabelEndMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelEnd': + pass + + def __enter__(self) -> 'LabelEnd': + pass + + +class LabelEnd( + YANGContainer, + metaclass=LabelEndMeta): + """ + YANG container handler. + + YANG name: label-end + """ + + _yang_name: Final[str] = 'label-end' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelEndMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelEnd': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_end/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8985523ba0c69fac8fbd1852bd47f2891d92bc6 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStartMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-start + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-start + """ + + def __init__(self): + super().__init__(LabelStart) + + def __get__(self, instance, owner=None) -> ( + 'LabelStartMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStart': + pass + + def __enter__(self) -> 'LabelStart': + pass + + +class LabelStart( + YANGContainer, + metaclass=LabelStartMeta): + """ + YANG container handler. + + YANG name: label-start + """ + + _yang_name: Final[str] = 'label-start' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelStartMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStart': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_start/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_step/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_step/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7d3aeed125a790da60e394f9e834fb871ab9c3b9 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_step/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelStepMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-step + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-step + """ + + def __init__(self): + super().__init__(LabelStep) + + def __get__(self, instance, owner=None) -> ( + 'LabelStepMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelStep': + pass + + def __enter__(self) -> 'LabelStep': + pass + + +class LabelStep( + YANGContainer, + metaclass=LabelStepMeta): + """ + YANG container handler. + + YANG name: label-step + """ + + _yang_name: Final[str] = 'label-step' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelStep': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + LabelStepMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + LabelStepMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_step/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_step/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_step/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_step/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_step/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/label_restrictions/label_restriction/label_step/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8dbcffdcef6a5a8e5db53b62fce3a3f123ea450f --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MaxLinkBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: max-link-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: max-link-bandwidth + """ + + def __init__(self): + super().__init__(MaxLinkBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'MaxLinkBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'MaxLinkBandwidth': + pass + + def __enter__(self) -> 'MaxLinkBandwidth': + pass + + +class MaxLinkBandwidth( + YANGContainer, + metaclass=MaxLinkBandwidthMeta): + """ + YANG container handler. + + YANG name: max-link-bandwidth + """ + + _yang_name: Final[str] = 'max-link-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + MaxLinkBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MaxLinkBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_link_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..92e8cf6bf3d3ec018101b740c97d4721224527f7 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class MaxResvLinkBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: max-resv-link-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: max-resv-link-bandwidth + """ + + def __init__(self): + super().__init__(MaxResvLinkBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'MaxResvLinkBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'MaxResvLinkBandwidth': + pass + + def __enter__(self) -> 'MaxResvLinkBandwidth': + pass + + +class MaxResvLinkBandwidth( + YANGContainer, + metaclass=MaxResvLinkBandwidthMeta): + """ + YANG container handler. + + YANG name: max-resv-link-bandwidth + """ + + _yang_name: Final[str] = 'max-resv-link-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + MaxResvLinkBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'MaxResvLinkBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/max_resv_link_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/te_nsrlgs/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/te_nsrlgs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e5e97fc164047e8b36086ca3700f75d61848220c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/te_nsrlgs/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeNsrlgsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-nsrlgs + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-nsrlgs + """ + + def __init__(self): + super().__init__(TeNsrlgs) + + def __get__(self, instance, owner=None) -> ( + 'TeNsrlgsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeNsrlgs': + pass + + def __enter__(self) -> 'TeNsrlgs': + pass + + +class TeNsrlgs( + YANGContainer, + metaclass=TeNsrlgsMeta): + """ + YANG container handler. + + YANG name: te-nsrlgs + """ + + _yang_name: Final[str] = 'te-nsrlgs' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeNsrlgs': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/te_srlgs/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/te_srlgs/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..561b31be827190ecd2cf49c88adb2118e8018b00 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/te_srlgs/__init__.py @@ -0,0 +1,79 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeSrlgsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-srlgs + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-srlgs + """ + + def __init__(self): + super().__init__(TeSrlgs) + + def __get__(self, instance, owner=None) -> ( + 'TeSrlgsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeSrlgs': + pass + + def __enter__(self) -> 'TeSrlgs': + pass + + +class TeSrlgs( + YANGContainer, + metaclass=TeSrlgsMeta): + """ + YANG container handler. + + YANG name: te-srlgs + """ + + _yang_name: Final[str] = 'te-srlgs' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeSrlgs': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..9ef388cd63aa7c8947fc3391bad703bb01f3d827 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/__init__.py @@ -0,0 +1,119 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay + """ + from .primary_path import PrimaryPath + from .tunnel_termination_points import TunnelTerminationPoints + from .tunnels import Tunnels + from .backup_path import BackupPath + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay + """ + + def __init__(self): + super().__init__(Underlay) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Underlay': + pass + + def __enter__(self) -> 'Underlay': + pass + + +class Underlay( + YANGContainer, + metaclass=UnderlayMeta): + """ + YANG container handler. + + YANG name: underlay + """ + + _yang_name: Final[str] = 'underlay' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'enabled': ( + enabled := YANGLeafMember( + 'enabled', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'protection-type': ( + protection_type := YANGLeafMember( + 'protection-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'primary-path': ( + primary_path := ( # YANGContainerMember( + UnderlayMeta. + PrimaryPath. + yang_container_descriptor())), + + 'tunnel-termination-points': ( + tunnel_termination_points := ( # YANGContainerMember( + UnderlayMeta. + TunnelTerminationPoints. + yang_container_descriptor())), + + 'tunnels': ( + tunnels := ( # YANGContainerMember( + UnderlayMeta. + Tunnels. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'backup-path': ( + backup_path := ( # YANGListMember( + UnderlayMeta. + BackupPath. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Underlay': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6b6e1ff5cb9da5f8c265df0f8c0854de089ff9ef --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/__init__.py @@ -0,0 +1,109 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class BackupPathMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: backup-path + """ + from .path_element import PathElement + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: backup-path + """ + + def __init__(self): + super().__init__(BackupPath) + + def __get__(self, instance, owner=None) -> ( + 'BackupPathMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['BackupPath']: + pass + + def __iter__(self, key) -> Iterator['BackupPath']: + return super().__iter__() + + def __getitem__(self, key) -> 'BackupPath': + return super()[key] + + def __enter__(self) -> ( + 'BackupPathMeta.yang_list_descriptor'): + pass + + +class BackupPath( + YANGListItem, + metaclass=BackupPathMeta): + """ + YANG list item handler. + + YANG name: backup-path + """ + + _yang_name: Final[str] = 'backup-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'index', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'index': ( + index := YANGLeafMember( + 'index', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + BackupPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'BackupPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e16cb666ce1a7bc800b744b15e11b1d4b7279e6d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .as_number import AsNumber + from .label import Label + from .numbered_node_hop import NumberedNodeHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .numbered_link_hop import NumberedLinkHop + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..7fbc8696d952dbd4da8674d436ba19f95c93755d --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f2c993df52db1f2e1aa1085a57856c8585fcba58 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..088a2a9a5842516b7391cf36f8c90e94028a03d5 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/backup_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..34a2a729ce6d45e11174065699c428a7ac677a8b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PrimaryPathMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: primary-path + """ + from .path_element import PathElement + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: primary-path + """ + + def __init__(self): + super().__init__(PrimaryPath) + + def __get__(self, instance, owner=None) -> ( + 'PrimaryPathMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'PrimaryPath': + pass + + def __enter__(self) -> 'PrimaryPath': + pass + + +class PrimaryPath( + YANGContainer, + metaclass=PrimaryPathMeta): + """ + YANG container handler. + + YANG name: primary-path + """ + + _yang_name: Final[str] = 'primary-path' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'path-element': ( + path_element := ( # YANGListMember( + PrimaryPathMeta. + PathElement. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PrimaryPath': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1d5e7a0625d0a7e1ed45c21fef726919e7abb0df --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/__init__.py @@ -0,0 +1,106 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class PathElementMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: path-element + """ + from .type import Type + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: path-element + """ + + def __init__(self): + super().__init__(PathElement) + + def __get__(self, instance, owner=None) -> ( + 'PathElementMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['PathElement']: + pass + + def __iter__(self, key) -> Iterator['PathElement']: + return super().__iter__() + + def __getitem__(self, key) -> 'PathElement': + return super()[key] + + def __enter__(self) -> ( + 'PathElementMeta.yang_list_descriptor'): + pass + + +class PathElement( + YANGListItem, + metaclass=PathElementMeta): + """ + YANG list item handler. + + YANG name: path-element + """ + + _yang_name: Final[str] = 'path-element' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'path-element-id', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'path-element-id': ( + path_element_id := YANGLeafMember( + 'path-element-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'PathElement': + instance = super().__new__(cls) + instance._yang_choices = { + + 'type': + PathElementMeta.Type( + instance), + } + return instance + + @property + def type(self) -> ( + PathElementMeta.Type): + return self._yang_choices['type'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..82e2d504aaeb513b94637bc327bfe2492f2f2447 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/__init__.py @@ -0,0 +1,188 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TypeMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: type + """ + + from .numbered_node_hop import NumberedNodeHop + from .unnumbered_link_hop import UnnumberedLinkHop + from .as_number import AsNumber + from .numbered_link_hop import NumberedLinkHop + from .label import Label + + class numbered_node_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_node_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedNodeHop'): + pass + + class unnumbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.unnumbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.UnnumberedLinkHop'): + pass + + class as_number_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__( + TypeMeta.AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.as_number_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + def __enter__(self) -> ( + 'TypeMeta.AsNumber'): + pass + + class numbered_link_hop_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__( + TypeMeta.NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.numbered_link_hop_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + def __enter__(self) -> ( + 'TypeMeta.NumberedLinkHop'): + pass + + class label_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__( + TypeMeta.Label) + + def __get__(self, instance, owner=None) -> ( + 'TypeMeta.label_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TypeMeta.Label'): + pass + + def __enter__(self) -> ( + 'TypeMeta.Label'): + pass + + +class Type(YANGChoice, metaclass=TypeMeta): + """ + YANG choice handler. + + YANG name: type + """ + + _yang_name: Final[str] = 'type' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_node_hop_case_descriptor())), + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + unnumbered_link_hop_case_descriptor())), + + 'as-number': ( + as_number := ( # YANGChoiceCase( + TypeMeta. + as_number_case_descriptor())), + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGChoiceCase( + TypeMeta. + numbered_link_hop_case_descriptor())), + + 'label': ( + label := ( # YANGChoiceCase( + TypeMeta. + label_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/as_number/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/as_number/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a9e6397e1378c9d49d0720f95118a7bc09d8d589 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/as_number/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number + """ + from .as_number_hop import AsNumberHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number + """ + + def __init__(self): + super().__init__(AsNumber) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumber': + pass + + def __enter__(self) -> 'AsNumber': + pass + + +class AsNumber( + YANGContainer, + metaclass=AsNumberMeta): + """ + YANG container handler. + + YANG name: as-number + """ + + _yang_name: Final[str] = 'as-number' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'as-number-hop': ( + as_number_hop := ( # YANGContainerMember( + AsNumberMeta. + AsNumberHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumber': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d4d7cc089c766991270dfdd2f888bff8b38bb49 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/as_number/as_number_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class AsNumberHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: as-number-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: as-number-hop + """ + + def __init__(self): + super().__init__(AsNumberHop) + + def __get__(self, instance, owner=None) -> ( + 'AsNumberHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'AsNumberHop': + pass + + def __enter__(self) -> 'AsNumberHop': + pass + + +class AsNumberHop( + YANGContainer, + metaclass=AsNumberHopMeta): + """ + YANG container handler. + + YANG name: as-number-hop + """ + + _yang_name: Final[str] = 'as-number-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'as-number': ( + as_number := YANGLeafMember( + 'as-number', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'AsNumberHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f3d584796ce0d9f70bed72da335de382683781da --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label + """ + from .label_hop import LabelHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label + """ + + def __init__(self): + super().__init__(Label) + + def __get__(self, instance, owner=None) -> ( + 'LabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Label': + pass + + def __enter__(self) -> 'Label': + pass + + +class Label( + YANGContainer, + metaclass=LabelMeta): + """ + YANG container handler. + + YANG name: label + """ + + _yang_name: Final[str] = 'label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'label-hop': ( + label_hop := ( # YANGContainerMember( + LabelMeta. + LabelHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Label': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2203b992611860dfd058f330ff7fd5f4d751e43c --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class LabelHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: label-hop + """ + from .te_label import TeLabel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: label-hop + """ + + def __init__(self): + super().__init__(LabelHop) + + def __get__(self, instance, owner=None) -> ( + 'LabelHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'LabelHop': + pass + + def __enter__(self) -> 'LabelHop': + pass + + +class LabelHop( + YANGContainer, + metaclass=LabelHopMeta): + """ + YANG container handler. + + YANG name: label-hop + """ + + _yang_name: Final[str] = 'label-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-label': ( + te_label := ( # YANGContainerMember( + LabelHopMeta. + TeLabel. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'LabelHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..cbf308375db86584b3adcea9d5c6d782f2307e12 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/__init__.py @@ -0,0 +1,95 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeLabelMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-label + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-label + """ + + def __init__(self): + super().__init__(TeLabel) + + def __get__(self, instance, owner=None) -> ( + 'TeLabelMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeLabel': + pass + + def __enter__(self) -> 'TeLabel': + pass + + +class TeLabel( + YANGContainer, + metaclass=TeLabelMeta): + """ + YANG container handler. + + YANG name: te-label + """ + + _yang_name: Final[str] = 'te-label' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeLabel': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeLabelMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeLabelMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/label/label_hop/te_label/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..75b0008fe318c4c34997b7532696828e42b85abf --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + from .numbered_link_hop import NumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-link-hop': ( + numbered_link_hop := ( # YANGContainerMember( + NumberedLinkHopMeta. + NumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1abedb4d3f8145943387f3e66e3e17fed741dcdc --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_link_hop/numbered_link_hop/__init__.py @@ -0,0 +1,97 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-link-hop + """ + + def __init__(self): + super().__init__(NumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedLinkHop': + pass + + def __enter__(self) -> 'NumberedLinkHop': + pass + + +class NumberedLinkHop( + YANGContainer, + metaclass=NumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: numbered-link-hop + """ + + _yang_name: Final[str] = 'numbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0ceac062e9d2ce79e6681b5f812cb2adae4a9ca --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + from .numbered_node_hop import NumberedNodeHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'numbered-node-hop': ( + numbered_node_hop := ( # YANGContainerMember( + NumberedNodeHopMeta. + NumberedNodeHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b8413f9714b640282ccc3b07327104536c117b38 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/numbered_node_hop/numbered_node_hop/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NumberedNodeHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: numbered-node-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: numbered-node-hop + """ + + def __init__(self): + super().__init__(NumberedNodeHop) + + def __get__(self, instance, owner=None) -> ( + 'NumberedNodeHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'NumberedNodeHop': + pass + + def __enter__(self) -> 'NumberedNodeHop': + pass + + +class NumberedNodeHop( + YANGContainer, + metaclass=NumberedNodeHopMeta): + """ + YANG container handler. + + YANG name: numbered-node-hop + """ + + _yang_name: Final[str] = 'numbered-node-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NumberedNodeHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..18213797fc567b08150fc431ac7611ef32d54622 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/__init__.py @@ -0,0 +1,86 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + from .unnumbered_link_hop import UnnumberedLinkHop + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'unnumbered-link-hop': ( + unnumbered_link_hop := ( # YANGContainerMember( + UnnumberedLinkHopMeta. + UnnumberedLinkHop. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c8ee74a2b7c7f647d2a88dfb22f44ed0ec1e80e4 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/primary_path/path_element/type/unnumbered_link_hop/unnumbered_link_hop/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnnumberedLinkHopMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: unnumbered-link-hop + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: unnumbered-link-hop + """ + + def __init__(self): + super().__init__(UnnumberedLinkHop) + + def __get__(self, instance, owner=None) -> ( + 'UnnumberedLinkHopMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnnumberedLinkHop': + pass + + def __enter__(self) -> 'UnnumberedLinkHop': + pass + + +class UnnumberedLinkHop( + YANGContainer, + metaclass=UnnumberedLinkHopMeta): + """ + YANG container handler. + + YANG name: unnumbered-link-hop + """ + + _yang_name: Final[str] = 'unnumbered-link-hop' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'direction': ( + direction := YANGLeafMember( + 'direction', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'hop-type': ( + hop_type := YANGLeafMember( + 'hop-type', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'link-tp-id': ( + link_tp_id := YANGLeafMember( + 'link-tp-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'node-id': ( + node_id := YANGLeafMember( + 'node-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnnumberedLinkHop': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/tunnel_termination_points/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/tunnel_termination_points/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c5cccf39482c3497e05c1c7ab8f4fdd3e2d7490b --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/tunnel_termination_points/__init__.py @@ -0,0 +1,91 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelTerminationPointsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnel-termination-points + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnel-termination-points + """ + + def __init__(self): + super().__init__(TunnelTerminationPoints) + + def __get__(self, instance, owner=None) -> ( + 'TunnelTerminationPointsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TunnelTerminationPoints': + pass + + def __enter__(self) -> 'TunnelTerminationPoints': + pass + + +class TunnelTerminationPoints( + YANGContainer, + metaclass=TunnelTerminationPointsMeta): + """ + YANG container handler. + + YANG name: tunnel-termination-points + """ + + _yang_name: Final[str] = 'tunnel-termination-points' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'destination': ( + destination := YANGLeafMember( + 'destination', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'source': ( + source := YANGLeafMember( + 'source', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TunnelTerminationPoints': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/tunnels/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/tunnels/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..303858f3e0c28faecf9696d2fbf403d5510cced8 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/tunnels/__init__.py @@ -0,0 +1,92 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelsMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: tunnels + """ + from .tunnel import Tunnel + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: tunnels + """ + + def __init__(self): + super().__init__(Tunnels) + + def __get__(self, instance, owner=None) -> ( + 'TunnelsMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Tunnels': + pass + + def __enter__(self) -> 'Tunnels': + pass + + +class Tunnels( + YANGContainer, + metaclass=TunnelsMeta): + """ + YANG container handler. + + YANG name: tunnels + """ + + _yang_name: Final[str] = 'tunnels' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + + 'tunnel': ( + tunnel := ( # YANGListMember( + TunnelsMeta. + Tunnel. + yang_list_descriptor())), + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnels': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/tunnels/tunnel/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/tunnels/tunnel/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f854dfd329ce016317b7b9743ace874769f03094 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/underlay/tunnels/tunnel/__init__.py @@ -0,0 +1,102 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TunnelMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: tunnel + """ + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: tunnel + """ + + def __init__(self): + super().__init__(Tunnel) + + def __get__(self, instance, owner=None) -> ( + 'TunnelMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['Tunnel']: + pass + + def __iter__(self, key) -> Iterator['Tunnel']: + return super().__iter__() + + def __getitem__(self, key) -> 'Tunnel': + return super()[key] + + def __enter__(self) -> ( + 'TunnelMeta.yang_list_descriptor'): + pass + + +class Tunnel( + YANGListItem, + metaclass=TunnelMeta): + """ + YANG list item handler. + + YANG name: tunnel + """ + + _yang_name: Final[str] = 'tunnel' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'tunnel-name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'sharing': ( + sharing := YANGLeafMember( + 'sharing', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'tunnel-name': ( + tunnel_name := YANGLeafMember( + 'tunnel-name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Tunnel': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fd4e9d8a913ee8fb4ba711c3d10310583ea16711 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/__init__.py @@ -0,0 +1,103 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnreservedBandwidthMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: unreserved-bandwidth + """ + from .te_bandwidth import TeBandwidth + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: unreserved-bandwidth + """ + + def __init__(self): + super().__init__(UnreservedBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'UnreservedBandwidthMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['UnreservedBandwidth']: + pass + + def __iter__(self, key) -> Iterator['UnreservedBandwidth']: + return super().__iter__() + + def __getitem__(self, key) -> 'UnreservedBandwidth': + return super()[key] + + def __enter__(self) -> ( + 'UnreservedBandwidthMeta.yang_list_descriptor'): + pass + + +class UnreservedBandwidth( + YANGListItem, + metaclass=UnreservedBandwidthMeta): + """ + YANG list item handler. + + YANG name: unreserved-bandwidth + """ + + _yang_name: Final[str] = 'unreserved-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'priority', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'priority': ( + priority := YANGLeafMember( + 'priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-bandwidth': ( + te_bandwidth := ( # YANGContainerMember( + UnreservedBandwidthMeta. + TeBandwidth. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnreservedBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/te_bandwidth/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/te_bandwidth/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..21c93df9e732a17da394efda2c59b6166de1374a --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/te_bandwidth/__init__.py @@ -0,0 +1,89 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeBandwidthMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-bandwidth + """ + from .technology import Technology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-bandwidth + """ + + def __init__(self): + super().__init__(TeBandwidth) + + def __get__(self, instance, owner=None) -> ( + 'TeBandwidthMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeBandwidth': + pass + + def __enter__(self) -> 'TeBandwidth': + pass + + +class TeBandwidth( + YANGContainer, + metaclass=TeBandwidthMeta): + """ + YANG container handler. + + YANG name: te-bandwidth + """ + + _yang_name: Final[str] = 'te-bandwidth' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeBandwidth': + instance = super().__new__(cls) + instance._yang_choices = { + + 'technology': + TeBandwidthMeta.Technology( + instance), + } + return instance + + @property + def technology(self) -> ( + TeBandwidthMeta.Technology): + return self._yang_choices['technology'] diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b7c35cb35140e0059a8596a975e71e1cfa92c717 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/__init__.py @@ -0,0 +1,72 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TechnologyMeta(type): + """ + Metaclass for YANG choice handler. + + YANG name: technology + """ + + from .generic import Generic + + class generic_case_descriptor(YANGChoiceCase): + """ + YANG choice case descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__( + TechnologyMeta.Generic) + + def __get__(self, instance, owner=None) -> ( + 'TechnologyMeta.generic_case_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + def __enter__(self) -> ( + 'TechnologyMeta.Generic'): + pass + + +class Technology(YANGChoice, metaclass=TechnologyMeta): + """ + YANG choice handler. + + YANG name: technology + """ + + _yang_name: Final[str] = 'technology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_cases: Final[Dict[str, YANGChoiceCase]] = { + + 'generic': ( + generic := ( # YANGChoiceCase( + TechnologyMeta. + generic_case_descriptor())), + } diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/generic/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/generic/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..81dce6de335c51cb366c8fa8c6fe4d53dbad586e --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/link_template/te_link_attributes/unreserved_bandwidth/te_bandwidth/technology/generic/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class GenericMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: generic + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: generic + """ + + def __init__(self): + super().__init__(Generic) + + def __get__(self, instance, owner=None) -> ( + 'GenericMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'Generic': + pass + + def __enter__(self) -> 'Generic': + pass + + +class Generic( + YANGContainer, + metaclass=GenericMeta): + """ + YANG container handler. + + YANG name: generic + """ + + _yang_name: Final[str] = 'generic' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'generic': ( + generic := YANGLeafMember( + 'generic', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'Generic': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/node_template/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/node_template/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b2973312bf2c09a332f8dc3751bd797b11115c98 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/node_template/__init__.py @@ -0,0 +1,115 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final, Iterator, List, Tuple + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class NodeTemplateMeta(type): + """ + Metaclass for YANG list item handler. + + YANG name: node-template + """ + from .te_node_attributes import TeNodeAttributes + + class yang_list_descriptor( + YANGListMember): + """ + YANG list descriptor class. + + YANG name: node-template + """ + + def __init__(self): + super().__init__(NodeTemplate) + + def __get__(self, instance, owner=None) -> ( + 'NodeTemplateMeta.yang_list_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> List['NodeTemplate']: + pass + + def __iter__(self, key) -> Iterator['NodeTemplate']: + return super().__iter__() + + def __getitem__(self, key) -> 'NodeTemplate': + return super()[key] + + def __enter__(self) -> ( + 'NodeTemplateMeta.yang_list_descriptor'): + pass + + +class NodeTemplate( + YANGListItem, + metaclass=NodeTemplateMeta): + """ + YANG list item handler. + + YANG name: node-template + """ + + _yang_name: Final[str] = 'node-template' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_list_key_names: Final[Tuple[str]] = ( + 'name', + ) + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'reference-change-policy': ( + reference_change_policy := YANGLeafMember( + 'reference-change-policy', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'priority': ( + priority := YANGLeafMember( + 'priority', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'te-node-attributes': ( + te_node_attributes := ( # YANGContainerMember( + NodeTemplateMeta. + TeNodeAttributes. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'NodeTemplate': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/node_template/te_node_attributes/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/node_template/te_node_attributes/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..d33037182fea0bb3aaf9c33036500240c54c6058 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/node_template/te_node_attributes/__init__.py @@ -0,0 +1,110 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class TeNodeAttributesMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: te-node-attributes + """ + from .underlay_topology import UnderlayTopology + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: te-node-attributes + """ + + def __init__(self): + super().__init__(TeNodeAttributes) + + def __get__(self, instance, owner=None) -> ( + 'TeNodeAttributesMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'TeNodeAttributes': + pass + + def __enter__(self) -> 'TeNodeAttributes': + pass + + +class TeNodeAttributes( + YANGContainer, + metaclass=TeNodeAttributesMeta): + """ + YANG container handler. + + YANG name: te-node-attributes + """ + + _yang_name: Final[str] = 'te-node-attributes' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'name': ( + name := YANGLeafMember( + 'name', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'is-abstract': ( + is_abstract := YANGLeafMember( + 'is-abstract', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'domain-id': ( + domain_id := YANGLeafMember( + 'domain-id', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + + 'admin-status': ( + admin_status := YANGLeafMember( + 'admin-status', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + + 'underlay-topology': ( + underlay_topology := ( # YANGContainerMember( + TeNodeAttributesMeta. + UnderlayTopology. + yang_container_descriptor())), + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'TeNodeAttributes': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/node_template/te_node_attributes/underlay_topology/__init__.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/node_template/te_node_attributes/underlay_topology/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..42dee7a72fe4a5d79128cf6ad278af68094e6692 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/bindings/networks/te/templates/node_template/te_node_attributes/underlay_topology/__init__.py @@ -0,0 +1,85 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import Dict, Final + +from .. import ( + YANGChoice, YANGChoiceCase, YANGContainer, YANGContainerMember, + YANGLeafMember, YANGListItem, YANGListMember) + + +class UnderlayTopologyMeta(type): + """ + Metaclass for YANG container handler. + + YANG name: underlay-topology + """ + + class yang_container_descriptor( + YANGContainerMember): + """ + YANG container descriptor class. + + YANG name: underlay-topology + """ + + def __init__(self): + super().__init__(UnderlayTopology) + + def __get__(self, instance, owner=None) -> ( + 'UnderlayTopologyMeta.yang_container_descriptor'): + return super().__get__(instance, owner) + + def __call__(self) -> 'UnderlayTopology': + pass + + def __enter__(self) -> 'UnderlayTopology': + pass + + +class UnderlayTopology( + YANGContainer, + metaclass=UnderlayTopologyMeta): + """ + YANG container handler. + + YANG name: underlay-topology + """ + + _yang_name: Final[str] = 'underlay-topology' + _yang_namespace: Final[str] = 'urn:ietf:params:xml:ns:yang:ietf-te-topology' + _yang_module_name: Final[str] = 'ietf-te-topology' + + _yang_leaf_members: Final[Dict[str, YANGLeafMember]] = { + + 'network-ref': ( + network_ref := YANGLeafMember( + 'network-ref', + 'urn:ietf:params:xml:ns:yang:ietf-te-topology', + 'ietf-te-topology')), + } + + _yang_container_members: Final[Dict[str, YANGContainerMember]] = { + } + + _yang_list_members: Final[Dict[str, YANGListMember]] = { + } + + _yang_choices: Final[Dict[str, YANGChoice]] = None + + def __new__(cls, *args, **kwargs) -> 'UnderlayTopology': + instance = super().__new__(cls) + instance._yang_choices = { + } + return instance diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/ietf-network-slice-service.txt b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/ietf-network-slice-service.txt new file mode 100644 index 0000000000000000000000000000000000000000..b81498dd8aa94457e2658cc29586de66242ae391 --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/ietf-network-slice-service.txt @@ -0,0 +1,261 @@ +# IETF draft-ietf-teas-ietf-network-slice-nbi-yang-02 - IETF Network Slice Service YANG Model +# Ref: https://datatracker.ietf.org/doc/draft-ietf-teas-ietf-network-slice-nbi-yang/ + +module: ietf-network-slice-service + +--rw network-slice-services + +--rw slo-sle-templates + | +--rw slo-sle-template* [id] + | +--rw id string + | +--rw template-description? string + +--rw slice-service* [service-id] + +--rw service-id string + +--rw service-description? string + +--rw service-tags + | +--rw tag-type* [tag-type] + | | +--rw tag-type identityref + | | +--rw value* string + | +--rw tag-opaque* [tag-name] + | +--rw tag-name string + | +--rw value* string + +--rw (slo-sle-policy)? + | +--:(standard) + | | +--rw slo-sle-template? leafref + | +--:(custom) + | +--rw service-slo-sle-policy + | +--rw policy-description? string + | +--rw metric-bounds + | | +--rw metric-bound* [metric-type] + | | +--rw metric-type identityref + | | +--rw metric-unit string + | | +--rw value-description? string + | | +--rw bound? uint64 + | +--rw security* identityref + | +--rw isolation? identityref + | +--rw max-occupancy-level? uint8 + | +--rw mtu? uint16 + | +--rw steering-constraints + | +--rw path-constraints + | +--rw service-function + +--rw status + | +--rw admin-status + | | +--rw status? identityref + | | +--rw last-updated? yang:date-and-time + | +--ro oper-status + | +--ro status? identityref + | +--ro last-updated? yang:date-and-time + +--rw sdps + | +--rw sdp* [sdp-id] + | +--rw sdp-id string + | +--rw sdp-description? string + | +--rw location + | | +--rw altitude? int64 + | | +--rw latitude? decimal64 + | | +--rw longitude? decimal64 + | +--rw node-id? string + | +--rw sdp-ip? inet:ip-address + | +--rw service-match-criteria + | | +--rw match-criterion* [index] + | | +--rw index uint32 + | | +--rw match-type + | | | identityref + | | +--rw value* string + | | +--rw target-connection-group-id leafref + | | +--rw connection-group-sdp-role? + | | | identityref + | | +--rw target-connectivity-construct-id? leafref + | +--rw sdp-peering + | | +--rw protocol* [protocol-type] + | | | +--rw protocol-type identityref + | | | +--rw attribute* [attribute-type] + | | | +--rw attribute-type identityref + | | | +--rw value* string + | | +--rw opaque* [attribute-name] + | | +--rw attribute-name string + | | +--rw value* string + | +--rw attachment-circuits + | | +--rw attachment-circuit* [ac-id] + | | +--rw ac-id string + | | +--rw ac-description? string + | | +--rw ac-node-id? string + | | +--rw ac-tp-id? string + | | +--rw ac-ip-address? inet:ip-address + | | +--rw ac-ip-prefix-length? uint8 + | | +--rw ac-qos-policy-name? string + | | +--rw mtu? uint16 + | | +--rw ac-tags + | | | +--rw ac-tags* [ac-tag-type] + | | | | +--rw ac-tag-type identityref + | | | | +--rw value* string + | | | +--rw ac-tag-opaque* [tag-name] + | | | +--rw tag-name string + | | | +--rw value* string + | | +--rw service-match-criteria + | | | +--rw match-criterion* [index] + | | | +--rw index + | | | | uint32 + | | | +--rw match-type + | | | | identityref + | | | +--rw value* + | | | | string + | | | +--rw target-connection-group-id leafref + | | | +--rw connection-group-sdp-role? + | | | | identityref + | | | +--rw target-connectivity-construct-id? leafref + | | +--rw sdp-peering + | | | +--rw protocol* [protocol-type] + | | | | +--rw protocol-type identityref + | | | | +--rw attribute* [attribute-type] + | | | | +--rw attribute-type identityref + | | | | +--rw value* string + | | | +--rw opaque* [attribute-name] + | | | +--rw attribute-name string + | | | +--rw value* string + | | +--rw incoming-rate-limits + | | | +--rw cir? uint64 + | | | +--rw cbs? uint64 + | | | +--rw eir? uint64 + | | | +--rw ebs? uint64 + | | | +--rw pir? uint64 + | | | +--rw pbs? uint64 + | | +--rw outgoing-rate-limits + | | +--rw cir? uint64 + | | +--rw cbs? uint64 + | | +--rw eir? uint64 + | | +--rw ebs? uint64 + | | +--rw pir? uint64 + | | +--rw pbs? uint64 + | +--rw incoming-rate-limits + | | +--rw cir? uint64 + | | +--rw cbs? uint64 + | | +--rw eir? uint64 + | | +--rw ebs? uint64 + | | +--rw pir? uint64 + | | +--rw pbs? uint64 + | +--rw outgoing-rate-limits + | | +--rw cir? uint64 + | | +--rw cbs? uint64 + | | +--rw eir? uint64 + | | +--rw ebs? uint64 + | | +--rw pir? uint64 + | | +--rw pbs? uint64 + | +--rw status + | | +--rw admin-status + | | | +--rw status? identityref + | | | +--rw last-updated? yang:date-and-time + | | +--ro oper-status + | | +--ro status? identityref + | | +--ro last-updated? yang:date-and-time + | +--ro sdp-monitoring + | +--ro incoming-utilized-bandwidth? + | | te-types:te-bandwidth + | +--ro incoming-bw-utilization decimal64 + | +--ro outgoing-utilized-bandwidth? + | | te-types:te-bandwidth + | +--ro outgoing-bw-utilization decimal64 + +--rw connection-groups + +--rw connection-group* [connection-group-id] + +--rw connection-group-id string + +--rw connectivity-type? identityref + +--rw (slo-sle-policy)? + | +--:(standard) + | | +--rw slo-sle-template? leafref + | +--:(custom) + | +--rw service-slo-sle-policy + | +--rw policy-description? string + | +--rw metric-bounds + | | +--rw metric-bound* [metric-type] + | | +--rw metric-type identityref + | | +--rw metric-unit string + | | +--rw value-description? string + | | +--rw bound? uint64 + | +--rw security* identityref + | +--rw isolation? identityref + | +--rw max-occupancy-level? uint8 + | +--rw mtu? uint16 + | +--rw steering-constraints + | +--rw path-constraints + | +--rw service-function + +--rw connectivity-construct* [cc-id] + | +--rw cc-id uint32 + | +--rw (connectivity-construct-type)? + | | +--:(p2p) + | | | +--rw p2p-sender-sdp? + | | | | -> ../../../../sdps/sdp/sdp-id + | | | +--rw p2p-receiver-sdp? + | | | -> ../../../../sdps/sdp/sdp-id + | | +--:(p2mp) + | | | +--rw p2mp-sender-sdp? + | | | | -> ../../../../sdps/sdp/sdp-id + | | | +--rw p2mp-receiver-sdp* + | | | -> ../../../../sdps/sdp/sdp-id + | | +--:(a2a) + | | +--rw a2a-sdp* [sdp-id] + | | +--rw sdp-id + | | | -> ../../../../../sdps/sdp/sdp-id + | | +--rw (slo-sle-policy)? + | | +--:(standard) + | | | +--rw slo-sle-template? leafref + | | +--:(custom) + | | +--rw service-slo-sle-policy + | | +--rw policy-description? + | | | string + | | +--rw metric-bounds + | | | +--rw metric-bound* + | | | [metric-type] + | | | +--rw metric-type + | | | | identityref + | | | +--rw metric-unit + | | | | string + | | | +--rw value-description? + | | | | string + | | | +--rw bound? + | | | uint64 + | | +--rw security* + | | | identityref + | | +--rw isolation? + | | | identityref + | | +--rw max-occupancy-level? + | | | uint8 + | | +--rw mtu? + | | | uint16 + | | +--rw steering-constraints + | | +--rw path-constraints + | | +--rw service-function + | +--rw (slo-sle-policy)? + | | +--:(standard) + | | | +--rw slo-sle-template? leafref + | | +--:(custom) + | | +--rw service-slo-sle-policy + | | +--rw policy-description? string + | | +--rw metric-bounds + | | | +--rw metric-bound* [metric-type] + | | | +--rw metric-type + | | | | identityref + | | | +--rw metric-unit string + | | | +--rw value-description? string + | | | +--rw bound? uint64 + | | +--rw security* identityref + | | +--rw isolation? identityref + | | +--rw max-occupancy-level? uint8 + | | +--rw mtu? uint16 + | | +--rw steering-constraints + | | +--rw path-constraints + | | +--rw service-function + | +--ro connectivity-construct-monitoring + | +--ro one-way-min-delay? uint32 + | +--ro one-way-max-delay? uint32 + | +--ro one-way-delay-variation? uint32 + | +--ro one-way-packet-loss? decimal64 + | +--ro two-way-min-delay? uint32 + | +--ro two-way-max-delay? uint32 + | +--ro two-way-delay-variation? uint32 + | +--ro two-way-packet-loss? decimal64 + +--ro connection-group-monitoring + +--ro one-way-min-delay? uint32 + +--ro one-way-max-delay? uint32 + +--ro one-way-delay-variation? uint32 + +--ro one-way-packet-loss? decimal64 + +--ro two-way-min-delay? uint32 + +--ro two-way-max-delay? uint32 + +--ro two-way-delay-variation? uint32 + +--ro two-way-packet-loss? decimal64 \ No newline at end of file diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/ofc23_batch_slices.py b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/ofc23_batch_slices.py new file mode 100644 index 0000000000000000000000000000000000000000..c38d75d063374b896ce6767c035175df8774c8ff --- /dev/null +++ b/src/compute/service/rest_server/nbi_plugins/ietf_network_slice/ofc23_batch_slices.py @@ -0,0 +1,158 @@ +# Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/) +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +import random +import uuid +import sys +import time +import requests + +from bindings.network_slice_services import NetworkSliceServices + + +# R1 emulated devices +# Port 13-0 is Optical +# Port 13-1 is Copper +R1_UUID = "ed2388eb-5fb9-5888-a4f4-160267d3e19b" +R1_PORT_13_0_UUID_OPTICAL = "20440915-1a6c-5e7b-a80f-b0e0e51f066d" +R1_PORT_13_1_UUID_COPPER = "ff900d5d-2ac0-576c-9628-a2d016681f9d" + +# R2 emulated devices +# Port 13-0 is Optical +# Port 13-1 is Copper +R2_UUID = "49ce0312-1274-523b-97b8-24d0eca2d72d" +R2_PORT_13_0_UUID_OPTICAL = "214618cb-b63b-5e66-84c2-45c1c016e5f0" +R2_PORT_13_1_UUID_COPPER = "4e0f7fb4-5d22-56ad-a00e-20bffb4860f9" + +# R3 emulated devices +# Port 13-0 is Optical +# Port 13-1 is Copper +R3_UUID = "3bc8e994-a3b9-5f60-9c77-6608b1d08313" +R3_PORT_13_0_UUID_OPTICAL = "da5196f5-d651-5def-ada6-50ed6430279d" +R3_PORT_13_1_UUID_COPPER = "43d221fa-5701-5740-a129-502131f5bda2" + +# R4 emulated devices +# Port 13-0 is Optical +# Port 13-1 is Copper +R4_UUID = "b43e6361-2573-509d-9a88-1793e751b10d" +R4_PORT_13_0_UUID_OPTICAL = "241b74a7-8677-595c-ad65-cc9093c1e341" +R4_PORT_13_1_UUID_COPPER = "c57abf46-caaf-5954-90cc-1fec0a69330e" + +node_dict = {R1_PORT_13_1_UUID_COPPER: R1_UUID, + R2_PORT_13_1_UUID_COPPER: R2_UUID, + R3_PORT_13_1_UUID_COPPER: R3_UUID, + R4_PORT_13_1_UUID_COPPER: R4_UUID} +list_endpoints = [R1_PORT_13_1_UUID_COPPER, + R2_PORT_13_1_UUID_COPPER, + R3_PORT_13_1_UUID_COPPER, + R4_PORT_13_1_UUID_COPPER] + +list_availability= [99, 99.9, 99.99, 99.999, 99.9999] +list_bw = [10, 40, 50, 100, 150, 200, 400] +list_owner = ["Telefonica", "CTTC", "Telenor", "ADVA", "Ubitech", "ATOS"] + +URL_POST = "/restconf/data/ietf-network-slice-service:ietf-nss/network-slice-services" +URL_DELETE = "/restconf/data/ietf-network-slice-service:ietf-nss/network-slice-services/slice-service=" + +def generate_request(seed: str) -> (dict, str): + + ns = NetworkSliceServices() + + # Slice 1 + suuid = str(uuid.uuid5(uuid.NAMESPACE_DNS, str(seed))) + slice1 = ns.slice_service[suuid] + slice1.service_description = "Test slice for OFC 2023 demo" + slice1.status().admin_status().status = "Planned" # TODO not yet mapped + + ''' + SDPS: + R1 optical to R3 optical + ''' + sdps1 = slice1.sdps().sdp + while True: + ep1_uuid = random.choice(list_endpoints) + ep2_uuid = random.choice(list_endpoints) + if ep1_uuid != ep2_uuid: + break + + sdps1[ep1_uuid].node_id = node_dict.get(ep1_uuid) + sdps1[ep2_uuid].node_id = node_dict.get(ep2_uuid) + + ''' + Connectivity group + Connection construct and 2 sla constrains: + - Bandwidth + - Availability + ''' + cg_uuid = str(uuid.uuid4()) + cg = slice1.connection_groups().connection_group + cg1 = cg[cg_uuid] + + cc1 = cg1.connectivity_construct[0] + cc1.cc_id = 5 + p2p = cc1.connectivity_construct_type.p2p() + p2p.p2p_sender_sdp = ep1_uuid + p2p.p2p_receiver_sdp = ep2_uuid + + slo_custom = cc1.slo_sle_policy.custom() + metric_bounds = slo_custom.service_slo_sle_policy().metric_bounds().metric_bound + + # SLO Bandwidth + slo_bandwidth = metric_bounds["service-slo-two-way-bandwidth"] + slo_bandwidth.value_description = "Guaranteed bandwidth" + slo_bandwidth.bound = int(random.choice(list_bw)) + slo_bandwidth.metric_unit = "Gbps" + + # SLO Availability + slo_availability = metric_bounds["service-slo-availability"] + slo_availability.value_description = "Guaranteed availability" + slo_availability.metric_unit = "percentage" + slo_availability.bound = random.choice(list_availability) + + json_request = {"data": ns.to_json()} + + #Last, add name and owner manually + list_name_owner = [{"tag-type": "owner", "value": random.choice(list_owner)}] + json_request["data"]["ietf-network-slice-service:network-slice-services"]["slice-service"][0]["service-tags"] = list_name_owner + + return (json_request, suuid) + + +if __name__ == "__main__": + print("Generating requests...") + num = int(sys.argv[2]) + ip = str(sys.argv[1]) + list_requests = [] + + for i in range(num): + request = generate_request(i) + list_requests.append(request) + print(f"HTTP.POST={request[0]}-{request[1]}") + time.sleep(2) + requests.post(f"http://{ip}{URL_POST}", auth=("admin", "admin"), json=request[0]) + + print("Slices sent, please press Enter key to delete them...") + input() + + for request,suuid in list_requests: + requests.delete(f"http://{ip}{URL_DELETE}{suuid}", auth=("admin", "admin")) + print(f"HTTP.DELETE={suuid}") + time.sleep(2) + print("All slices deleted!") + + + + + diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/tools/Authentication.py b/src/compute/service/rest_server/nbi_plugins/tools/Authentication.py similarity index 100% rename from src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/tools/Authentication.py rename to src/compute/service/rest_server/nbi_plugins/tools/Authentication.py diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/tools/HttpStatusCodes.py b/src/compute/service/rest_server/nbi_plugins/tools/HttpStatusCodes.py similarity index 100% rename from src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/tools/HttpStatusCodes.py rename to src/compute/service/rest_server/nbi_plugins/tools/HttpStatusCodes.py diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/tools/Validator.py b/src/compute/service/rest_server/nbi_plugins/tools/Validator.py similarity index 100% rename from src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/tools/Validator.py rename to src/compute/service/rest_server/nbi_plugins/tools/Validator.py diff --git a/src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/tools/__init__.py b/src/compute/service/rest_server/nbi_plugins/tools/__init__.py similarity index 100% rename from src/compute/service/rest_server/nbi_plugins/ietf_l2vpn/tools/__init__.py rename to src/compute/service/rest_server/nbi_plugins/tools/__init__.py